<!DOCTYPE html>
<html lang="en">
  <head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="author" content="Zhou Wei <zromyk@163.com>">
  <title>计算机考研-操作系统</title>
  <link rel="shortcut icon" href="/favicon.ico">
  <link rel="stylesheet" href="/style/pure.css">
  <link rel="stylesheet" href="/style/main.css">
  <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/4.7.0/css/font-awesome.css">
  <script src='/style/latest.js?config=TeX-MML-AM_CHTML'></script>
  <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
  <script src='/style/Valine.min.js'></script>
  <link href="https://apps.bdimg.com/libs/highlight.js/9.1.0/styles/default.min.css" rel="stylesheet">
  <script src="https://apps.bdimg.com/libs/highlight.js/9.1.0/highlight.min.js"></script>
  <script>hljs.initHighlightingOnLoad();</script>
  <script src="https://cdn.geogebra.org/apps/deployggb.js"></script>
  <script src="https://cdn1.lncld.net/static/js/2.5.0/av-min.js"></script>
  <script src='/style/readTimes.js'></script>
</head>
<body>
  <div id="menu-background"></div>
  <div id="menu">
    <div class="pure-menu pure-menu-horizontal">
  <div id="menu-block">
    <ul class="pure-menu-list">
      <a class="pure-menu-heading" href="/index.html">ZROMYK</a>
<li class="pure-menu-item">
  <a class="pure-menu-link" href="/index.html">主页</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" href="/public/archive/index.html">归档</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" href="/public/download/index.html">下载</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" href="/public/feedback/index.html">反馈</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" href="/public/about/index.html">关于我</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" href="https://github.com/zromyk"><i class="fa fa-github" style="font-size:32px"></i></a>
</li>

    </ul>
  </div>
</div>

  </div>
  <div id="layout">
    <div class="content">
      <div id="content-articles">
  <h1 id="计算机考研-操作系统" class="content-subhead">计算机考研-操作系统</h1>
  <p>
    <span>1970-01-01</span>
    <span><span class="post-category post-category-cs">CS</span></span>
    <span id="/public/article/计算机考研-操作系统.html" class="leancloud_visitors" style="display:none" data-flag-title="计算机考研-操作系统"></span>
  </p>
  <h1 id="_1">第一章 操作系统概述</h1>
<h2 id="1">1.操作系统的特征</h2>
<h4 id="1_1">1.特征</h4>
<ul>
<li>并发（Concurrence）：两个或多个事件在同一时间间隔内发生。</li>
<li>共享（Sharing）：互斥共享方式、同时访问方式。</li>
<li>虚拟（Virtual）：利用多道程序设计技术把一个物理上的CPU虚拟为多个逻辑上的CPU，称为虚拟处理器。</li>
<li>异步（Asynchronism）：进程的执行并不是一贯到底，而是走走停停，以不可预知的速度向前推进，这就是进程的异步性。</li>
</ul>
<h4 id="2">2.处理机管理</h4>
<ul>
<li>进程控制</li>
<li>进程同步</li>
<li>进程通信</li>
<li>死锁处理</li>
<li>处理机调度</li>
</ul>
<h4 id="3">3.存储器管理</h4>
<ul>
<li>内存分配与回收</li>
<li>地址映射</li>
<li>内存保护与共享</li>
<li>内存扩充</li>
</ul>
<h4 id="4">4.文件管理</h4>
<ul>
<li>文件存储空间管理</li>
<li>目录管理</li>
<li>文件读写管理和保护</li>
</ul>
<h4 id="5">5.设备管理</h4>
<ul>
<li>缓冲管理</li>
<li>设备分配</li>
<li>设备处理</li>
<li>虚拟设备</li>
</ul>
<h2 id="2_1">2.操作系统的发展与分类</h2>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>操作系统</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>单道批处理系统</td>
<td></td>
</tr>
<tr>
<td>多道批处理系统</td>
<td>优点：<br />1. 系统开销大，资源利用率高<br />2. 系统吞吐量大<br />缺点：<br />1. 用户响应时间较长<br />2. 不提供人机交互能力</td>
</tr>
<tr>
<td>分时操作系统</td>
<td></td>
</tr>
<tr>
<td>实时操作系统</td>
<td></td>
</tr>
<tr>
<td>网络操作系统<br />分布式计算机系统</td>
<td></td>
</tr>
<tr>
<td>个人计算机操作系统</td>
<td></td>
</tr>
<tr>
<td>嵌入式操作系统<br />服务器操作系统<br />智能手机操作系统</td>
<td></td>
</tr>
</tbody>
</table></div>
<h2 id="3_1">3.操作系统的运行机制</h2>
<h4 id="1_2">1.系统内核程序（内核态）</h4>
<ol>
<li>上层<ol>
<li>进程管理</li>
<li>存储器管理</li>
<li>设备管理</li>
</ol>
</li>
<li>底层<ol>
<li>时钟管理</li>
<li>设备驱动</li>
<li>中断机制</li>
</ol>
</li>
</ol>
<h4 id="2_2">2.用户自编程序（用户态）</h4>
<p>由用户态转向核心态的例子：</p>
<ol>
<li>用户程序要求操作系统的服务（系统调用）</li>
<li>发生中断</li>
<li>用户程序中产生了一个错误状态</li>
<li>用户程序汇总企图执行一条特权指令</li>
<li>从核心态转向用户态（特权指令，一般是中断返回指令）</li>
</ol>
<h4 id="3_2">3.特权指令</h4>
<ol>
<li>计算机中不允许用户直接使用的指令</li>
<li>I/O指令</li>
<li>置中断指令</li>
<li>存取用于内存保护的寄存器指令</li>
<li>送程序状态字道程序状态寄存器指令</li>
</ol>
<h4 id="4_1">4.原语</h4>
<ul>
<li>处于操作系统的最底层，最接近硬件的部分</li>
<li>这些程序的运行具有原子性，其操作只能一气呵成</li>
<li>这些程序的运行时间都较短，而且调用频繁</li>
</ul>
<h4 id="5_1">5.异常（内中断）</h4>
<ul>
<li>程序的非法操作码</li>
<li>地址越界</li>
<li>算数溢出</li>
<li>虚存系统的缺页及专门的陷入指令</li>
</ul>
<h4 id="6">6.中断</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>执行对象</th>
<th>过程</th>
</tr>
</thead>
<tbody>
<tr>
<td>中断隐指令（硬件自动）</td>
<td>1、关中断（在保护现场的过程中，CPU不应该响应更高优先级中断源的中断请求）<br />2、<strong>保存断点</strong><br />3、<strong>引出中断服务程序</strong></td>
</tr>
<tr>
<td>中断服务程序</td>
<td>4、<strong>保存现场</strong>和屏蔽字（需要在关中断下进行）<br />5、开中断<br />6、执行中断服务程序<br />7、关中断<br />8、<strong>恢复现场</strong>和屏蔽字（需要在关中断下进行）<br />9、开中断、中断返回</td>
</tr>
</tbody>
</table></div>
<h4 id="7">7.系统调用</h4>
<ul>
<li>设备管理</li>
<li>文件管理</li>
<li>进程控制</li>
<li>进程通信</li>
<li>内存管理</li>
</ul>
<p>在用户程序中，凡是与资源有关的操作，都必须通过系统调用的方式向操作系统提出服务请求，并由操作系统代为完成。</p>
<h3 id="_2">知识点</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点</th>
</tr>
</thead>
<tbody>
<tr>
<td>1.【2009】<strong>单处理机</strong>系统中，可并行的是【II，III，IV】<br /><br />&gt; I. 进程与进程<br />&gt; II. 处理机与设备✔︎<br />&gt; III. 处理机与通道✔︎<br />&gt; IV. 设备与设备✔︎</td>
</tr>
<tr>
<td>2.【2010】下列选项中，操作系统提供给应用进程的接口是【A】<br /><br />&gt; 【<strong>A. 系统调用</strong>】<br />&gt; B. 中断<br />&gt; C. 库函数<br />&gt; D. 原语</td>
</tr>
<tr>
<td>3.【2011第24题】下列选项中，在<strong>用户态</strong>执行的是【A】<br /><br />&gt; 【<strong>A.命令解释程序</strong>】<br />&gt; B.缺页处理程序（核心态）<br/>&gt; C.进程调度程序（核心态）<br />&gt; D.时钟中断处理程序（核心态）</td>
</tr>
<tr>
<td>4.【2012第23题】下列选项中，<strong>不可能在用户态</strong>发生的事件是【】<br /><br />&gt; A. 系统调用<br />&gt; B. 外部中断<br />&gt; 【C. 进程切换】（核心态）<br />&gt; D. 缺页</td>
</tr>
<tr>
<td>5.【2012第24题】中断处理和子程序调用都需要压栈以保护现场，<strong>中断处理一定会保存</strong>而<strong>子程序调</strong>用不需要保存其内容的是【B】<br /><br />&gt; A.程序计数器<br />&gt; 【<strong>B.程序状态字寄存器</strong>】<br/>&gt; C.通用数据寄存器<br />&gt; D.通用地址寄存器<br /><br />子程序调用：只需要保存程序计数器PC（断点）<br />中断调用：程序计数器PC（断点）和程序状态字寄存器PSW</td>
</tr>
<tr>
<td>6.【2013第28题】下列选项中，会导致用户进程从用户态切换到内核态的是【I，III】<br /><br />&gt; 【I. 整数除以零】<br />&gt; II. sin( )函数调用<br />&gt; 【III. read系统调用】</td>
</tr>
<tr>
<td>7.【2013第29题】计算机开机以后，操作系统最终被加载到【D】<br /><br />&gt; A. BIOS<br />&gt; B. ROM<br />&gt; C. EPROM<br />&gt; 【<strong>D. RAM</strong>】内存</td>
</tr>
<tr>
<td>8.【2014第25题】下列指令，<strong>不能</strong>在<strong>用户态</strong>执行的是【D】<br /><br />&gt; A. trap指令<br />&gt; B. 跳转指令<br />&gt; C. 压栈指令<br />&gt; 【D. 关中断指令】（特权指令）</td>
</tr>
<tr>
<td>9.【2015第22题】内部异常(内中断)可分为故障(fault)、陷阱(trap)和终止(abort)三类。下列有关内部异常的叙述中，<strong>错误</strong>的是【D】<br /><br />&gt; A.内部异常的产生与当前执行指令相关<br/>&gt; B.内部异常的检测由CPU内部逻辑实现<br/>&gt; C.内部异常的响应发生在指令执行过程中<br/>&gt; 【D.内部异常处理后返回到发生异常的指令继续执行】（部分异常处理完之后不会回到之前的指令继续执行）</td>
</tr>
<tr>
<td>10.【2015第23题】处理<strong>外部中断</strong>时，应该<strong>由操作系统保存</strong>的是【B】<br /><br />&gt; A.程序计数器(PC)的内容（由中断隐指令保存）<br />&gt; 【<strong>B.通用寄存器的内容</strong>】（由操作系统保存）<br/>&gt; C.快表(TLB)中的内容<br />&gt; D.Cache中的内容</td>
</tr>
<tr>
<td>11.【2015第24题】假定下列指令已装入指令寄存器，则执行时<strong>不可能导致</strong>CPU从用户态变为内核态(系统态)的是【C】<br /><br />&gt; A.DIV R0，R1；(R0)/(R1)-&gt;R0<br/>&gt; B.INT n；软中断<br/>&gt; 【C.NOT R0；把寄存器中的内容取非】（不是取倒数）<br/>&gt; D.MOV R0，addr；把地址addr处的内存数据放入寄存器R0中</td>
</tr>
<tr>
<td>12.【2016第23题】下列关于<strong>批处理系统</strong>的叙述中，正确的是【II，III】<br /><br />&gt; I.批处理系统允许<u>多个用户</u>与计算机直接交互<br />&gt; 【<strong>II.批处理系统分为单道批处理系统和多道批处理系统</strong>】<br />&gt; 【<strong>III.中断技术使得多道批处理系统的I/O设备可与CPU并行工作</strong>】</td>
</tr>
<tr>
<td>13.【2016第22题】<u>异常是指令执行过程中在处理器内部发生的特殊事件，中断是来自处理器外部的请求事件。</u>下列关于中断或异常情况的叙述中，<strong>错误</strong>的是【A】<br /><br />&gt; 【A.“访存时缺页”属于中断】（属于异常）<br/>&gt; B.“整数除以0”属于异常<br/>&gt; C.“DMA传送结束”属于中断<br/>&gt; D.“存储保护错”属于异常</td>
</tr>
<tr>
<td>14.【2017第28题】与单道程序系统相比，多道程序系统的优点是【I、III、IV】<br /><br />&gt; 【I.CPU利用率高】<br />&gt; II.系统开销小（错误，需要在多个任务之间切换，系统开销更大） <br />&gt; 【III.系统吞吐量大】 <br />&gt; 【IV.I/O设备利用率高】</td>
</tr>
<tr>
<td><u>15.【2017第24题】执行<strong>系统调用</strong>的过程包括如下主要操作【C】</u><br /><br />&gt; 1返回用户态<br />&gt; 2执行陷入(trap)指令<br/>&gt; 3传递系统调用参数<br />&gt; 4执行相应的服务程序<br/><br /> 正确的执行顺序是<br/> A.2→3→1→4 B.2→4→3→1<br/> 【<strong>C.3→2→4→1</strong>】 D.3→4→2→1<br /><br />注意：<strong>C.3→2→4→1</strong></td>
</tr>
<tr>
<td>16.【2018第23题】下列关于<strong>多任务操作系统</strong>的叙述中，正确的是【I，II】<br /><br />&gt; 【I. 具有并发和并行的特点】<br/>&gt; 【II. 需要实现对共享资源的保护】<br />&gt; III. 需要运行在多 CPU 的硬件平台上（可以运行在单CPU的处理机上）</td>
</tr>
<tr>
<td>17.【2018年考研408第29题】当定时器产生时钟中断后，由<strong>时钟中断服务程序更新</strong>的部分内容是【I，II，III】<br /><br />&gt; I. 内核中时钟变量的值✔︎<br />&gt; II. 当前进程占用CPU的时间✔︎<br />&gt; III. 当前进程在时间片内的剩余执行时间✔︎<br /><br />由<strong>时钟中断服务程序更新</strong>的部分内容：系统时间，进程时间片，延迟，使用CPU的时间，各种定时器。</td>
</tr>
<tr>
<td>18.【2019】下列关于系统调用的叙述中，正确的是【C】<br/><br />【I. 在执行系统调用服务程序的过程中,CPU处于内核态】<br/>【II. 操作系统通过提供系统调用避免用户程序直接访向外设】<br/>III. <u>不同的操作系统</u>为应用程序提供了<u>统一的系统调用</u>接口<br/>【IV. 系统调用是操作系统内核为应用程序提供服务的接口】<br/><br />&gt; A. 仅I、V<br/>&gt; B. 仅II、III<br/>&gt; C. 仅I、II、IV<br/>&gt; D. 仅I、III、IV</td>
</tr>
</tbody>
</table></div>
<h1 id="_3">第二章 进程管理</h1>
<h2 id="1_3">1.进程与线程</h2>
<h4 id="1_4">1.进程的概念和特征</h4>
<h5 id="1_5">1、进程映像</h5>
<ol>
<li>程序段</li>
<li>相关数据段</li>
<li>PCB（进程控制块），进程存在的唯一标志</li>
</ol>
<h4 id="2_3">2.进程的状态与转换</h4>
<h5 id="1_6">1、进程状态</h5>
<ol>
<li>运行态</li>
<li>就绪态</li>
<li>阻塞态</li>
<li>创建态</li>
<li>结束态</li>
</ol>
<h4 id="3_3">3.进程控制</h4>
<h5 id="1pcb">1、PCB（进程控制块）</h5>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>进程描述信息</th>
<th>进程控制和管理信息</th>
<th>资源分配清单</th>
<th>处理机相关信息</th>
</tr>
</thead>
<tbody>
<tr>
<td>进程标识符（PID）</td>
<td>进程当前状态</td>
<td>代码段指针</td>
<td>通用寄存器值</td>
</tr>
<tr>
<td>用户标识符（UID）</td>
<td>进程优先级</td>
<td>数据段指针</td>
<td>地址寄存器值</td>
</tr>
<tr>
<td></td>
<td>代码运行入口地址</td>
<td>堆栈段指针</td>
<td>控制寄存器值</td>
</tr>
<tr>
<td></td>
<td>程序的外存地址</td>
<td>文件描述符</td>
<td>标志寄存器值</td>
</tr>
<tr>
<td></td>
<td>进入内存时间</td>
<td>键盘</td>
<td>状态字（PSW）</td>
</tr>
<tr>
<td></td>
<td>处理机占用时间</td>
<td>鼠标</td>
<td></td>
</tr>
<tr>
<td></td>
<td>信号量使用</td>
<td></td>
<td></td>
</tr>
</tbody>
</table></div>
<h4 id="4_2">4.进程的组织</h4>
<h4 id="5_2">5.进程通信</h4>
<h4 id="6_1">6.线程的概念与多线程模型</h4>
<h2 id="2_4">2.处理机调度</h2>
<h4 id="1_7">1.调度的概念</h4>
<p><strong>调度的层次：</strong></p>
<ol>
<li>作业调度（高级调度）</li>
<li>内存调度（中级调度）：提高内存利用率和系统吞吐量。</li>
<li>进程调度（低级调度，最基本的，不可或缺的）</li>
</ol>
<h4 id="2_5">2.调度的时机、切换与过程</h4>
<p><strong>不能进行进程的调度和切换的情况：</strong></p>
<ol>
<li>处理中断的过程中。</li>
<li>进程在操作系统内核程序临界区中。</li>
<li>其他需要完全屏蔽中断的原子操作过程中。</li>
</ol>
<h4 id="3_4">3.进程调度方式</h4>
<ol>
<li>非剥夺调度方式，非抢占式。</li>
<li>剥夺调度方式，抢占式。</li>
</ol>
<h4 id="4_3">4.调度的基本准则</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>进程调度的基本准则</th>
<th>描述</th>
</tr>
</thead>
<tbody>
<tr>
<td>CPU利用率</td>
<td></td>
</tr>
<tr>
<td>系统吞吐量</td>
<td>单位时间内CPU<strong>完成作业的数量</strong>。</td>
</tr>
<tr>
<td>周转时间</td>
<td>
<script type="math/tex; mode=display">周转时间=作业完成时间-\underline{作业提交时间}</script><br /><script type="math/tex; mode=display">平均周转时间=\cfrac{1}{n}(作业1的周转时间+...+作业n的周转时间)</script><br /><script type="math/tex; mode=display">带权周转时间=\cfrac{作业周转时间}{作业实际运行时间}=\cfrac{作业完成时间-作业提交时间}{作业实际运行时间}</script><br /><script type="math/tex; mode=display">平均带权周转时间=\cfrac{1}{n}(作业1的带权周转时间+...+作业n的带权周转时间)</script>
</td>
</tr>
<tr>
<td>等待时间</td>
<td>指进程处于等待处理机状态的时间之和，等待时间越长，用户满意度越低。</td>
</tr>
<tr>
<td>响应时间</td>
<td>指从用户提交请求到系统首次产生响应所用的时间。</td>
</tr>
</tbody>
</table></div>
<h4 id="5_3">5.典型的调度算法</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>进程调度算法</th>
<th>描述</th>
<th>特点</th>
</tr>
</thead>
<tbody>
<tr>
<td>1. 先来先服务（FCFS）算法</td>
<td></td>
<td>1. 效率低<br />2. 有利于CPU繁忙型作业，不利于IO繁忙型作业</td>
</tr>
<tr>
<td>2. 短作业优先（SJF）算法</td>
<td></td>
<td>1. 存在“饥饿现象”<br />2. SJF算法的平均等待时间、平均周转时间<strong>最少</strong></td>
</tr>
<tr>
<td>3. 优先级调度算法</td>
<td>1. 非剥夺式优先级调度算法<br />2. 剥夺式优先级调度算法<br /><br />1. 静态优先级<br />2. 动态优先级</td>
<td></td>
</tr>
<tr>
<td>4. 高响应比优先调度算法</td>
<td>
<script type="math/tex; mode=display">响应比R_p=\cfrac{等待时间+要求服务时间}{要求服务时间}</script>
</td>
<td>兼顾长作业和短作业</td>
</tr>
<tr>
<td>5. 时间片轮转调度算法</td>
<td>时间片长短的影响因素：<br />1. 系统响应时间<br />2. 就绪队列中的进程数目<br />3. 系统的处理能力</td>
<td>适合分时操作系统</td>
</tr>
<tr>
<td>6. 多级反馈队列调度算法<br />（融合了前几种算法的优点）</td>
<td></td>
<td>终端型作业用户：短作业优先<br />短批处理作业用户：周转时间较短<br />长批处理作业用户：进过前面几个队列得到部分执行</td>
</tr>
</tbody>
</table></div>
<h2 id="3_5">3.进程同步</h2>
<h4 id="1_8">1.进程同步的基本概念</h4>
<h4 id="2_6">2.实现临界区互斥的基本方法</h4>
<h4 id="3_6">3.信号量</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>等待状态</th>
<th>描述</th>
</tr>
</thead>
<tbody>
<tr>
<td>死等状态</td>
<td>进程在有限时间内根本不能进入临界区，而一直在尝试进入，陷入一种无结果的等待状态。</td>
</tr>
<tr>
<td>忙等状态</td>
<td>当一个进程正处在某临界区内，任何试图进入其临界区的进程都必须进入代码连续循环，陷入忙等状态。连续测试一个变量直到某个值出现为止，称为忙等。</td>
</tr>
<tr>
<td>有限等待</td>
<td>对要求访问临界资源的进程，应保证有限时间内能进入自己的临界区，以免陷入“死等”状态。</td>
</tr>
<tr>
<td>让权等待</td>
<td>当进程不能进入自己的临界区时，应<strong>立即释放处理机</strong>，以免进程陷入“忙等”状态。</td>
</tr>
</tbody>
</table></div>
<h5 id="1_9">1.整形信号量（忙碌等待）</h5>
<pre><code class="pre-wrap"><span style="overflow-x: auto; max-width:100%; display:inline;"><code class="language-c">void wait(S) {
    while(S &lt;= 0); // 忙碌等待，一直占有处理机
    S = S - 1;
}
void signal(S) {
    S = S + 1;
}
</code></span></code></pre>
<h5 id="2_7">2.记录型信号量（让权等待）</h5>
<pre><code class="pre-wrap"><span style="overflow-x: auto; max-width:100%; display:inline;"><code class="language-c">typedef syruct {
    int value;
    struct process *L;
}
void wait(S) {
    S.value--;
    if (S.value &lt; 0) {
        block(S.L); // 自我阻塞，释放处理机给其他进程
    }
}
void signal(S) {
    S.value++;
    if (S.value &lt;= 0) {
        waleup(S.L); // 将S.L中的第一个等待进程唤醒
    }
}
</code></span></code></pre>
<h5 id="3_7">3.利用信号量实现同步</h5>
<pre><code class="pre-wrap"><span style="overflow-x: auto; max-width:100%; display:inline;"><code class="language-c">semaphore S = 0;
void P1() {
    ...
    x;      // 执行语句x
    V(S);   // 告诉进程P2语句x已经完成，唤醒第一个因为信号量被阻塞的进程
    ...
}
void P2() {
    ...
    P(S);   // 检测语句x是否完成，若未完成，自我阻塞
    y;      // 检查通过，运行语句y
    ...
}
</code></span></code></pre>
<h5 id="4_4">4.利用信号量实现进程互斥</h5>
<pre><code class="pre-wrap"><span style="overflow-x: auto; max-width:100%; display:inline;"><code class="language-c">semaphore S = 1;
void P1() {
    ...
    P(S);               // 准备访问临界区，加锁
    /* 进程P1的临界区 */
    V(S);               // 访问结束，解锁
    ...
}
void P2() {
    ...
    P(S);               // 准备访问临界区，加锁
    /* 进程P2的临界区 */
    V(S);               // 访问结束，解锁
    ...
}
</code></span></code></pre>
<blockquote class="content-quote">
<p>临界区：</p>
<p>指的是一个访问共用资源（例如：共用设备或是共用存储器）的程序片段，而这些共用资源又无法同时被多个线程访问的特性。当有线程进入临界区段时，其他线程或是进程必须等待（例如：bounded waiting 等待法），有一些同步的机制必须在临界区段的进入点与离开点实现，以确保这些共用资源是被互斥获得使用，例如：semaphore。只能被单一线程访问的设备，例如：打印机。</p>
</blockquote>
<h4 id="4_5">4.管程</h4>
<h4 id="5_4">5.经典同步问题</h4>
<h2 id="4_6">4.死锁</h2>
<h4 id="1_10">1.死锁的概念</h4>
<h4 id="2_8">2.死锁的处理策略</h4>
<h4 id="3_8">3.死锁预防</h4>
<h4 id="4_7">4.死锁避免</h4>
<h4 id="5_5">5.死锁的检测和解除</h4>
<h3 id="_4">知识点（进程调度）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点</th>
</tr>
</thead>
<tbody>
<tr>
<td>1.【2010第24题】下列选项中，导致<strong>创建新进程</strong>的操作是【C】<br/><br/>【I 用户登录成功】<br/>II 设备分配<br/>【III 启动程序执行】<br/><br/>&gt; A.仅I 和II<br/>&gt; B.仅II 和III<br/>&gt; C.仅I 和III<br/>&gt; D.I 、II 和III</td>
</tr>
<tr>
<td>2.【2010第26题】下列选项中，降低进程优先级的合理时机是【A】<br/><br />&gt;【A. 进程的时间片用完】（此时降低优先级，可以让其他进程有更多的运行机会）<br/>&gt; B. 进程刚完成 I/O，进入就绪列队<br/>&gt; C. 进程长期处于就绪列队中<br/>&gt; D. 进程从就绪态转为运行态（应该在进程运行完成之后，才能降低优先级）</td>
</tr>
<tr>
<td>3.【2012第31题】下列关于进程和线程的叙述中，正确的是【A】<br/><br/>&gt; 【<strong>A.不管系统是否支持线程，进程都是资源分配的基本单位</strong>】 <br/>&gt; B.<u>线程</u>（<strong>进程</strong>✔︎）是资源分配的基本单位，<u>进程</u>（<strong>线程</strong>✔︎）是调度的基本单位 <br/>&gt; C.系统级线程和<u>用户级线程</u>的切换都需要内核的支持（用户级线程不需要） <br/>&gt; D.同一进程中的各个线程拥有各自<u>不同</u>的地址空间（同一进程的各个线程相同）</td>
</tr>
<tr>
<td>4.【2014】在支持多线程的系统中，进程P创建的若干线程<strong>不能共享</strong>的是【D】<br /><br />&gt; A. 进程P的代码段<br/>&gt; B. 进程P中打开的文件<br/>&gt; C. 进程P的全局变量<br/>&gt; 【D. 进程P中某线程的栈指针】</td>
</tr>
<tr>
<td>5.【2014第26题】一个进程的读磁盘操作完成后，操作系统针对该进程必做的是【A】<br /><br />&gt; 【A.修改进程状态为就绪态】<br />&gt; B.降低进程优先级<br />&gt; C.给进程分配用户内存空间<br />&gt; D.增加进程时间片大小</td>
</tr>
<tr>
<td>6.【2014第31题】下列关于管道(Pipe)通信的叙述中，正确的是【C】<br /><br />&gt; A.一个管道可实现双向数据传输<br/>&gt; B.管道的容量仅受磁盘容量大小限制（固定）<br />&gt; 【C.进程对管道进行读操作和写操作都可能被阻塞】<br />&gt; D.一个管道只能有一个读进程或一个写进程对其操作（可以多个进程同时读，或者写，但不能同时读和写）</td>
</tr>
<tr>
<td>7.【2015第25题】下列选项中，会导致进程从<strong>执行态</strong>变为<strong>就绪态</strong>的事件是【D】<br /><br />&gt; A.执行P(wait)操作<br />&gt; B.申请内存失败<br/>&gt; C.启动I/O设备<br />&gt;【D.被高优先级进程抢占】</td>
</tr>
<tr>
<td>8.【2018第27题】下列选项中，可能导致当前进程 P <strong>阻塞</strong>的事件是【I，II】<br /><br />&gt; 【I. 进程 P申请临界资源】<br/>&gt; 【II. 进程 P从磁盘读数据】<br/>&gt; III. 系统将 CPU 分配给高优先权的进程（会转为就绪态，而不是阻塞态）</td>
</tr>
<tr>
<td>9.【2019第23题】下列关于线程的描述中，错误的是【B】<br/><br />&gt; A.内核级线程的调度由操作系统完成（正确）<br/>&gt; B.操作系统为每个用户级<u>线程</u>建立一个线程控制块（错误，不是线程，而是进程）<br/>&gt; C.用户级线程间的切换比内核级线程间的切换效率高（正确）<br/>&gt; D.用户级线程可以在不支持内核级线程的操作系统上实现（正确，用户级线程可以不需要内核的支持）</td>
</tr>
<tr>
<td>10.【2019第24题】下列选项中，可能将进程<strong>唤醒</strong>的事件是【I，II】<br/><br />&gt; 【I. I/0结束】<br/>&gt; 【I.某进程退出临界区】<br/>&gt; III.当前进程的时间片用完<br /><br /><strong>唤醒：从阻塞态到就绪态</strong></td>
</tr>
</tbody>
</table></div>
<h3 id="_5">知识点（进程调度算法，待续&hellip;）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点</th>
</tr>
</thead>
<tbody>
<tr>
<td>1.【2009第24题】下列进程调度算法中，<u>综合考虑</u><strong>进程等待时间</strong>和<strong>执行时间</strong>的是【D】<br/><br />&gt; A.时间片轮转调度算法<br/>&gt; B.短进程优先调度算法<br/>&gt; C.先来先服务调度算法<br/>&gt;【D.高响应比优先调度算法】</td>
</tr>
<tr>
<td>【2011第23题】下列选项中，<strong>满足短任务优先</strong>且<strong>不会发生饥饿现象</strong>的调度算法是【B】<br /><br />&gt; A.先来先服务<br />&gt; 【B.高响应比优先】<br/>&gt; C.时间片轮转<br />&gt; D.非抢占式短任务优先</td>
</tr>
<tr>
<td>【2012第29题】一个多道批处理系统中仅有 P1 和 P2 两个作业，P2 比 P1 晚 5ms 到达，它们的计算和 I/O 操作顺序如下：<br />P1：计算 60ms，I/O 80ms，计算 20ms<br/>P2：计算 120ms，I/O 40ms，计算 40ms<br />若不考虑调度和切换时间，则完成两个作业需要的时间最少是 【】<br/><br />&gt; A. 240ms<br />&gt; B. 260ms<br />&gt; C. 340ms<br />&gt; D. 360ms</td>
</tr>
<tr>
<td>【2012第30题】若某单处理器多进程系统中有<strong>多个就绪态</strong>进程，则下列关于处理机调度的叙述中，<strong>错误</strong>的是【C】<br /><br />&gt; A.在进程结束时能进行处理机调度<br />&gt; B.创建新进程后能进行处理机调度<br />&gt; 【C.在进程处于临界区时不能进行处理机调度（错误）】<br />&gt; D.在系统调用完成并返回用户态时能进行处理机调度</td>
</tr>
<tr>
<td>【2013第31题】某系统正在执行三个进程 P1、P2 和 P3，各进程的计算(CPU)时间和 I/O 时间比例如下表所示，为提高系统资源利用率，合理的进程优先级设置应为【】<br /><br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 17.26.45.png" alt="截屏2020-12-10 17.26.45" style="zoom:67%;" /><br /><br />A. <script type="math/tex">P1>P2>P3</script><br />B. <script type="math/tex">P3>P2>P1</script><br />C. <script type="math/tex">P2>P1=P3</script><br />D. <script type="math/tex">P1>P2=P3</script>
</td>
</tr>
<tr>
<td>【2014第23题】下列调度算法中，<strong>不可能导致饥饿现象</strong>的是【A】<br /><br />&gt; 【A.时间片轮转】<br />&gt; B.静态优先数调度<br />&gt; C.非抢占式短作业优先<br />&gt; D.抢占式短作业优先</td>
</tr>
<tr>
<td>【2016第24题】某单CPU系统中有输入和输出设备各1台，现有3个并发执行的作业，每个作业的输入、计算和输出时间均分别为2 ms、3 ms和4 ms，且都按输入、计算和输出的顺序执行，则执行完3 个作业需要的时间最少是【】<br /><br />&gt; A.15 ms、B.17 ms、C.22 ms、D.27 ms</td>
</tr>
<tr>
<td>【2017第23题】假设4个作业到达系统的时刻和运行时间如下表所示系统在t=2时开始作业调度。若分别采用先来先服务和短作业优先调度算法，则选中的作业分别是【】<br /><br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 17.29.37.png" alt="截屏2020-12-10 17.29.37" style="zoom:67%;" /><br /><br />&gt; A. J2、J3<br />&gt; B. J1、J4<br />&gt; C. J2、J4<br />&gt; D. J1、J3</td>
</tr>
<tr>
<td>【2017第27题】下列有关基于时间片的进程调度的叙述中，<strong>错误</strong>的是【B】<br /><br />&gt; A.时间片越短，进程切换的次数越多，系统开销也越大<br />&gt; 【B.当前进程的时间片用完后，该进程状态由执行态变为<u>阻塞态</u>（就绪态）】<br />&gt; C.时钟中断发生后，系统会修改当前进程在时间片内的剩余时间<br />&gt; D.影响时间片大小的主要因素包括响应时间、系统开销和进程数量等</td>
</tr>
<tr>
<td>【2018第24题】某系统采用基于优先权的非抢占式进程调度策略，完成一次进程调度和进程切换的系统时间开销为 1μs。在 T 时刻就绪队列中有 3 个进程P1 、 P2 和 P3，其在就绪队列中的等待时间、需要的 CPU 时间和优先权如下表所示。<br /><br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 17.36.06.png" alt="截屏2020-12-10 17.36.06" style="zoom:67%;" /><br /><br />若优先权值大的进程优先获得CPU，从 T 时刻起系统开始进程调度，则系统的平均周转时间为【】<br /><br />A . 54 sμ B. 73 μs C. 74 μs D. 75 μs</td>
</tr>
<tr>
<td>【2019第27题】系统采用二级反馈队列调度算法进行进程调度。就绪队列Q1采用时间片轮转调度算法,时间片为10ms;就绪队列Q2采用短进程优先调度算法；系统优先调度Q1队列中的进程,当Q1为空时系统才会调度Q2中的进程；新创建的进程首先进入QI；Q1中的进程执行一个时间片后,若未结束,则转入Q2。若当前Q1、Q2为空，系统依次创建进程P1、P2后即开始进程调度P1、P2需要的CPU时间分别为30 ms和20 ms，则进程P1、P2在系统中的平均等待时间为【】<br/><br />A. 25 ms<br/>B. 20 ms<br/>C. 15 ms<br/>D. 10 ms</td>
</tr>
</tbody>
</table></div>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（解答题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2016第46题（6分）】某进程调度程序采用基于优先数(priority)的调度策略，即选择优先数最小的进程运行，进程创建时由用户指定一个nice作为静态优先数。为了动态调整优先数，引入运行时间 cpuTime和等待时间waitTime，初值均为0。进程处于执行态时，cpuTime定时加1，且waitTime 置0；进程处于就绪态时，cpuTime置0，waitTime定时加1。请回答下列问题。<br/>(1)若调度程序只将nice的值作为进程的优先数，即priority=nice，则可能会出现饥饿现象， 为什么?<br/>(2)使用nice、cpuTime和waitTime设计一种动态优先数计算方法，以避免产生饥饿现象，并 说明waitTime的作用。</td>
</tr>
</tbody>
</table></div>
<h3 id="_6">知识点（进程互斥，选择题）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（选择题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2010第25题】设与某资源关联的信号量初值为 3，当前值为 1。若 M 表示该资源的<strong>可用</strong>个数，N 表示<strong>等待</strong>该资源的进程数，则 M、N 分别是【B】<br /><br />&gt; A.0、1 <br />&gt;【B.1、0 】（<strong>注意：N表示等待该资源的进程数，只有当信号<script type="math/tex">K<0</script>时，才表示有<script type="math/tex">｜K｜</script>个进程在等待</strong>）<br />&gt; C.1、2（不要选择C） <br />&gt; D.2、0</td>
</tr>
<tr>
<td>【2010第27题】进程 P0 和 P1 的共享变量定义及其初值为<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.03.10.png" alt="截屏2020-12-10 19.03.10" style="zoom:67%;" /><br />若进程 P0 和 P1 访问临界资源的类 C 伪代码实现如下：<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.03.23.png" alt="截屏2020-12-10 19.03.23" style="zoom:67%;" /><br />则并发执行进程 P0 和 P1 时产生的情形是【D】<br/><br />A. 不能保证进程互斥进入临界区，会出现“饥饿”现象<br/>B. 不能保证进程互斥进入临界区，不会出现“饥饿”现象<br/>C. 能保证进程互斥进入临界区，会出现“饥饿”现象<br/>【D. 能保证进 程互斥 进入临 界区， 不会出 现“饥饿” 现象】<br /><br />【分析】这是Peterson算法的实现，可以保证进入临界区的进程和安全。</td>
</tr>
<tr>
<td>【2011第32题】有两个并发执行的进程P1和P2，共享<strong>初值为1</strong>的变量x。P1对x加1，P2对x减1。加1和减1操作的指令序列分别如下所示。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.09.04.png" alt="截屏2020-12-10 19.09.04" style="zoom:67%;" /><br />两个操作完成后，x的值【C】<br /><br/>A.可能为-1或3<br/>B.只能为1<br/>【C.可能为0、1或2】<br/>D.可能为-1、0、1或2</td>
</tr>
<tr>
<td>【2016第27题】使用TSL(Test and Set Lock)指令实现进程互斥的伪代码如下所示。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.07.21.png" alt="截屏2020-12-10 19.07.21" style="zoom:67%;" /><br />下列与该实现机制相关的叙述中，正确的是【B】<br /><br/>A. 退出临界区的进程负责唤醒阻塞态进程<br/>【B. 等待进入临界区的进程不会主动放弃CPU】<br/>C. 上述伪代码满足“让权等待”的同步准则<br/>D. while(TSL(&amp;lock))语句应在关中断状态下执行</td>
</tr>
<tr>
<td>【2016第30题】进程P1和P2均包含并发执行的线程，部分伪代码描述如下所示。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.05.02.png" alt="截屏2020-12-10 19.05.02" style="zoom:67%;" /><br />下列选项中，需要互斥执行的操作是【C】<br /><br/>A. <span style="overflow-x: auto; max-width:100%; display:inline;"><code>a=1</code></span>与<span style="overflow-x: auto; max-width:100%; display:inline;"><code>a=2</code></span><br />B. <span style="overflow-x: auto; max-width:100%; display:inline;"><code>a=x</code></span>与<span style="overflow-x: auto; max-width:100%; display:inline;"><code>b=x</code></span><br/>【C. <span style="overflow-x: auto; max-width:100%; display:inline;"><code>x+=1</code></span>与<span style="overflow-x: auto; max-width:100%; display:inline;"><code>x+=2</code></span>】（x是同一进程中的全局变量）<br />D. <span style="overflow-x: auto; max-width:100%; display:inline;"><code>x+=1</code></span>与<span style="overflow-x: auto; max-width:100%; display:inline;"><code>x+=3</code></span></td>
</tr>
<tr>
<td>【2016第32题】下列关于管程的叙述中，<strong>错误</strong>的是【A】<br /><br />【A. 管程只能用于实现进程的互斥】（管程也能实现进程间的同步）<br/><strong>B. 管程是由编程语言支持的进程同步机制✔︎<br/>C. 任何时候只能有一个进程在管程中执行✔︎ <br />D. 管程中定义的变量只能被管程内的过程访问✔︎</strong></td>
</tr>
<tr>
<td>【2018第25题】属于同一进程的两个线程thread1和thread2并发执行，共享初值为0的全局变量x。thread1和thread2实现对全局变量x加1的机器级代码描述如下。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.10.58.png" alt="截屏2020-12-10 19.10.58" style="zoom:67%;" /><br />在所有可能的指令执行序列中，使x的值为2的序列个数是【B】<br/><br/>A. 1  【B. 2】  C. 3  D. 4<br /><br />【分析】只能先执行完thread1再执行thread2，或者先执行完thread2再执行thread1.</td>
</tr>
<tr>
<td>【2018第28题】若 x 是管程内的条件变量，则当进程执行 x.wait() 时所做的工作是【D】<br /><br/>A. 实现对变量 x 的互斥访问<br/>B. 唤醒一个在 x 上阻塞的进程<br/>C. 根据 x 的值判断该进程是否进人阻塞状态<br/>【D. 阻塞该进程，并将之插入 x 的阻塞队列中】</td>
</tr>
<tr>
<td>【2018第32题】在下列同步机制中，可以实现<strong>让权等待</strong>的是【C】<br /><br />A. Peterson 方法（有限等待）<br/>B. swap指令<br/>【C. 信号量方法】<br />D. TestAndSet指令</td>
</tr>
</tbody>
</table></div>
<h3 id="_7">知识点（进程互斥，简答题）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（简答题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2009第45题（7分）】三个进程P1、P2、P3互斥使用一个包含N(N&gt;0)个单元的缓冲区。P1每次用produce()生成一个正整数并用put()送入缓冲区某一空单元中；P2每次用getodd()从该缓冲区中取出一个奇数并用countodd()统计奇数个数；P3每次用geteven()从该缓冲区中取出一个偶数并用counteven()统计偶数个数。请用信号量机制实现这三个进程的同步与互斥活动，并说明所定义信号量的含义。要求用伪代码描述。</td>
</tr>
<tr>
<td>【2011第45题（8分）】某银行提供 1 个服务窗口和 10 个供顾客等待的座位。顾客到达银行时，若有空座位，则到取号机上领取一个号，等待叫号。取号机每次仅允许一位顾客使用。当营业员空闲时，通过叫号选取一位顾客，并为其服务。顾客和营业员的活动过程描述如下:<br/>cobegin {<br/>  process 顾客 i {<br/>     从取号机获取一个号码;<br/>        等待叫号;<br/>      获取服务;<br/>  }<br/>  process 营业员 {<br/>      while(TRUE) {<br/>          叫号;<br/>            为客户服务;<br/>     } <br/> }<br/>}coend<br/>请添加必要的信号量和 P、V(或 wait()、signal())操作，实现上述过程中的互斥与同步。<br/>要求写出完整的过程，说明信号量的含义并赋初值。</td>
</tr>
<tr>
<td>【2013第45题（7分）】某博物馆最多可容纳 500 人同时参观，有一个出入口，该出入口一次仅允许一个人 通过。参观者的活动描述如下:<br/>cobegin<br/>参观者进程 i:<br/>{<br/>   &hellip;<br/>   进门;<br/>   &hellip;<br/>   参观;<br/>   &hellip;<br/>   出门;<br/>   &hellip;<br/>}<br/>coend<br/>请添加必要的信号量和 P、V(或 wait()、signal( )操作，以实现上述过程中的互斥 与同步。要求写出完整的过程，说明信号量的含义并赋初值。</td>
</tr>
<tr>
<td>【2014第47题】系统中有多个生产者进程和多个消费者进程，共享一个能存放 1000 件产品的环形 缓冲区(初始为空)。当缓冲区未满时，生产者进程可以放入其生产的一件产品，否则等待; 当缓冲区未空时，消费者进程可以从缓冲区取走一件产品，否则等待。要求一个消费者进程 从缓冲区连续取出 10 件产品后，其他消费者进程才可以取产品。请使用信号量 P，V(wait()， signal())操作实现进程间的互斥与同步，要求写出完整的过程，并说明所用信号量的含义和 初值。</td>
</tr>
<tr>
<td>【2015第45题（9分）】有A、B两人通过信箱进行辩论，每个人都从自己的信箱中取得对方的问题，将答案和向对方提 出的新问题组成一个邮件放人对方的信箱中。假设A的信箱最多放M个邮件，B的信箱最多放IV个邮件。初始 时A的信箱中有x个邮件(0&lt;x&lt;M)，B的信箱中有y个邮件(0&lt;y&lt;N)。辩论者每取出一个邮件，邮件数减1。A和B 两人的操作过程描述如下:<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.36.08.png" alt="截屏2020-12-10 19.36.08" style="zoom:67%;" /><br />当信箱不为空时，辩论者才能从信箱中取邮件，否则等待。当信箱不满时，辩论者才能将新邮件放入信 箱，否则等待。请添加必要的信号量和P、V(或wait、signal)操作，以实现上述过程的同步。要求写出完整的 过程，并说明信号量的含义和初值。</td>
</tr>
<tr>
<td>【2017第46题（8分）】某进程中有3个并发执行的线程thread1、thread2和thread3，其伪代码如下所示。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.37.37.png" alt="截屏2020-12-10 19.37.37" style="zoom:67%;" /><br />请添加必要的信号量和P、V(或wait( )、signal( ))操作，要求确保线程互斥访问临界资源， 并且最大程度地并发执行。</td>
</tr>
<tr>
<td>【2019第43题（8分）】有n(n≥3)位哲学家围坐在一张圆桌边,每位哲学家交替地就餐和思考。在圆桌中心有m(m≥1)个碗,每两位哲学家之间有.1根筷子。每位哲学家必须取到一个碗和两侧的筷子之后,才能就餐,进餐完毕,将碗和筷子放回原位,并继续思考。为使尽可能多的哲学家同时就餐,且防止出现死锁现象,请使用信号量的P、V操作(wait()、signal() 操作)描述上述过程中的互斥与同步,并说明所用信号量及初值的含义。</td>
</tr>
</tbody>
</table></div>
<h1 id="_8">第三章 内存管理</h1>
<h2 id="1_11">1.内存管理概念、基本原理和要求</h2>
<h4 id="1_12">1.内存管理</h4>
<ul>
<li>内存空间的分配与回收</li>
<li>地址转换</li>
<li>内存空间的扩展</li>
<li>存储保护</li>
</ul>
<h4 id="2_9">2.程序装入和链接</h4>
<ul>
<li>编译</li>
<li>链接<ul>
<li>静态链接</li>
<li>装入时动态链接</li>
<li>运行时动态链接</li>
</ul>
</li>
<li>装入<ul>
<li>绝对装入</li>
<li>可重定位装入：多个目标模块的起始地址从0开始，程序的其他地址都是相对于起始地址的。<ul>
<li>缺点：<ul>
<li>一个作业装入内存时，必须给他分配要求的全部内存空间。</li>
<li>作业一旦进入内存，整个运行期间就不能在内存中移动，也不能再申请内存空间。</li>
</ul>
</li>
</ul>
</li>
<li>动态重定位：需要一个重定位寄存器的支持（一个处理器只需要一个重定位寄存器）<br /><ul>
<li>特点：<ul>
<li>可以将程序分配到不连续的存储区。</li>
<li>在程序运行之前可以只装入他的部分代码即可投入运行，在程序运行期间，根据需要动态申请分配内存。</li>
<li>便于程序段的共享。</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="3_9">3.地址</h4>
<ul>
<li>逻辑地址：每个模块都从0号单元开始编址，这称为对该目标模块的相对地址。</li>
<li>虚拟地址：计算机处理器的地址有32位和64位的两种，对应的虚拟地址的空间大小分别是<script type="math/tex">2^{32}</script>字节和<script type="math/tex">2^{64}</script>字节，字节用B表示。</li>
<li>物理地址</li>
</ul>
<h4 id="4_8">4.内存保护</h4>
<ul>
<li>在CPU中设置一对上、下限寄存器，每当CPU要访问一个地址时，分别和这两个寄存器进行比较</li>
<li>重定位寄存器（基址寄存器）和界地址寄存器（限长寄存器）</li>
</ul>
<h2 id="2_10">2.覆盖与交换</h2>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>覆盖</td>
<td>分区：<br/>1. <strong>固定区</strong>：经常活跃的部分，其余部分按调用关系分段。<br/>2. <strong>若干覆盖区</strong>：即将要访问的段，其他段放置在外存，在需要调用前，系统将其掉入覆盖区，替换覆盖区原有内容。<br/>特点：<br/>打破了必须将一个进程的全部信息装入主存才能访问的限制，但当有同时运行的代码量大于主存时仍不能运行。</td>
</tr>
<tr>
<td>交换</td>
<td>思想：<br/>1. 把处于等待状态的程序从内存移动到外存（换出）<br/>2. 把准备好竞争CPU运行的程序从辅存移到内存（换入）<br/>需要注意的问题：<br/>1. 交换需要备份存储，通常是快速磁盘，必须足够大。<br/>2. 转移时间与所交换的内存空间成正比。<br/>3. 若换出进程，必须确保该进程完全处于空闲状态。<br/>4. 交换空间通常作为磁盘的一整块，且独立于文件系统。<br/>5. 交换通常在又许多进程运行且内存空间吃紧的时候开始，在系统负荷降低时暂停。</td>
</tr>
</tbody>
</table></div>
<p>交换技术主要在不同进程（或作业）之间进行，覆盖则用于同一个程序或进程。</p>
<h2 id="3_10">3.连续分配管理方式</h2>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>分配方式</th>
<th>描述</th>
<th>优点</th>
<th>缺点</th>
</tr>
</thead>
<tbody>
<tr>
<td>单一连续分配</td>
<td>内存在此方式下，分为系统区和用户区</td>
<td>1. 简单、无外部碎片。<br />2. 可以采用覆盖技术，不需要额外的技术支持。</td>
<td>1. 有内部碎片，存储器利用率极低。<br />2. 只能用于单用户、单任务的操作系统。</td>
</tr>
<tr>
<td>固定分区分配</td>
<td>将用户内存空间划分为若干固定大小的区域，每个区域只装入一道作业。<br />分区方法：<br/><strong>分区大小相等</strong>：用于利用一台计算机去控制多个相同对象的场合，缺乏灵活性<br/><strong>分区大小不相等</strong>：划分为多个较小的分区、适量的中等分区和少量大分区。</td>
<td>无外部碎片。</td>
<td>1. 程序可能太大放不进任何一个分区。<br />2. 有内部碎片，主存利用率低，当程序小于固定分区大小时，野战一个完整的内存分区空间。</td>
</tr>
<tr>
<td>动态分区分配</td>
<td>在进程装入内存时，根据进程的大小动态地建立分区</td>
<td>动态分配内存。</td>
<td>有外部碎片，内存利用率下降。</td>
</tr>
</tbody>
</table></div>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>分配算法</th>
<th>特点</th>
</tr>
</thead>
<tbody>
<tr>
<td>首次适应算法</td>
<td>最简单，通常是最好最快的。</td>
</tr>
<tr>
<td>最佳适应算法</td>
<td>产生最多外部（小）碎片。</td>
</tr>
<tr>
<td>最坏适应算法</td>
<td>会很快导致没有可用的大内存块。</td>
</tr>
<tr>
<td>临近适应算法</td>
<td>分配查找从上次查找结束地方开始查找。</td>
</tr>
</tbody>
</table></div>
<h2 id="4_9">4.非连续分配管理方式</h2>
<p>非连续分配方式的存储密度低于连续分配存储密度。</p>
<h4 id="1_13">1.基本分页存储管理方式和基本分段存储管理方式</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>基本分页存储管理方式</th>
<th>基本分段存储管理方式</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td><img class="pure-img" alt="截屏2020-11-17 22.01.41" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.01.41.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 22.02.09" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.02.09.png" /></td>
</tr>
<tr>
<td>特点</td>
<td>分区大小固定<br /><br />块的大小相对于分区小很多，一个进程占用多个块。</td>
<td>分区大小不固定<br /><br />段号和段内偏移必须由用户显式提供（不透明）在高级程序设计语言中，由编译器完成，分段在用户编程时就已经确定。</td>
</tr>
<tr>
<td>基本概念</td>
<td>页：将 <strong>逻辑地址</strong> 划分为同等大小的部分。<br />块或页框：把 <strong>物理内存</strong> 划分为同大小的连续的部分。<br />页和页框的大小相等。</td>
<td></td>
</tr>
<tr>
<td>逻辑地址结构</td>
<td><img class="pure-img" alt="截屏2020-11-17 22.02.42" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.02.42.png" />页面大小W =  4KB = 2^12B<br />页面数目P = 2^32B / 2^12B = 2^20页，每一页对应 4KB 逻辑地址<br />逻辑地址大小 4GB = 2^32B</td>
<td><img class="pure-img" alt="截屏2020-11-17 22.02.57" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.02.57.png" />逻辑地址结构是二维的，即段号和段内偏移量<br />在该地址结构中，允许一个作业最长有64K个段，每个段的最大长度为64KB</td>
</tr>
<tr>
<td>页（段）表地址结构</td>
<td>记录页面在内存中对应的物理块号（每个进程一个页表）<br />页表项：页表项连续存放，因此页号可以隐藏，不占用存储空间（类似数组）<br />因此可以将4B为单位存储页号对应的内存块号。</td>
<td>段号 + 段长 + 本段在主存的始址</td>
</tr>
<tr>
<td>逻辑地址A到物理地址E</td>
<td>1. 计算页号P（P = A / L）和页内偏移量W（W = A % L）<br/>2. 比较页号P和页表长度M，若P &gt;= M，则产生越界中断，否则继续执行。<br/>3. 页表中页号P对应的页表项地址 = 页表初始地址F + 页号P x 页表项长度。<br/>4. 计算 E = b x L + W，得到物理地址E</td>
<td>1. 逻辑地址A（前几位为段号S，后几位为段内偏移W）<br/>2. 比较段号S和段表长度M，若S &gt;= M，则产生越界中断，否则继续执行。<br/>3. 段表中段号S对应的段表项地址 = 段表始址F + 段号S x 段表项长度，从段表项的前几位得到段长C，若段内偏移 &gt;= C，则产生越界中断，否则继续执行。<br/>4. 取出段表项中该段的始址b，计算E = b + W，得到物理地址E</td>
</tr>
<tr>
<td></td>
<td>快表（相联存储器，TLB）：<br />1. CPU给出逻辑地址，由硬件地址转换，页号送入高速缓存寄存器，与快表中的所有页号比较。<br/>2. 若找到，直接在高速缓存寄存器中取出对应的页框号。<br/>3. 若未找到，访问主存中的页表，并更新快表。</td>
<td></td>
</tr>
<tr>
<td></td>
<td>二级页表：建立页表的页表，按需载入一级页表。<img class="pure-img" alt="截屏2020-11-17 22.09.24" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.09.24.png" /></td>
<td></td>
</tr>
<tr>
<td>地址保护方法</td>
<td>判断页号是否越界（页内偏移不可能越界）</td>
<td>存取控制保护<br />地址越界保护：<br />1. 段表寄存器中的段表长度与逻辑地址中的段号比较。<br/>2. 段表项重的段长和逻辑地址中的段内偏移比较。</td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<td>比较</td>
<td>页是信息的<strong>物理</strong>单位。</td>
<td>段是信息的<strong>逻辑</strong>单位。</td>
</tr>
<tr>
<td>主要目的</td>
<td>为了实现离散分配，提高内存利用率。分页仅仅是系统管理上的需要，完全是系统行为，对用户是不可见的。</td>
<td>更好地满足用户需求。一个段通常包含着一组属于一个逻辑模块的信息。分段对用户是可见的，用户编程时需要显式地给出段名。</td>
</tr>
<tr>
<td>大小</td>
<td>页的大小固定且由系统决定。</td>
<td>段的长度却不固定，决定于<strong>用户编写的程序</strong>。</td>
</tr>
<tr>
<td>地址空间维度</td>
<td>分页的用户进程地址空间是<strong>一维</strong>的，程序员只需给出一个记忆符即可表示一个地址。</td>
<td>分段的用户进程地址空间是<strong>二维</strong>的，程序员在标识-一个地址时，既要给出段名，也要给出段内地址。</td>
</tr>
<tr>
<td></td>
<td></td>
<td>分段比分页<strong>更容易实现信息的共享和保护</strong>。</td>
</tr>
</tbody>
</table></div>
<blockquote class="content-quote">
<p>不能被修改的代码称为纯代码或可重入代码(不属于临界资源)，这样的代码是可以共享的。</p>
<p>可修改的代码是不能共享的。</p>
</blockquote>
<h4 id="2_11">2.段页式管理方式</h4>
<p><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.03.47.png" alt="截屏2020-11-17 22.03.47" style="zoom:50%;" /></p>
<ul>
<li>逻辑地址结构：段页式管理方式中的逻辑地址结构</li>
<li>注意：在一个进程中，段表只有一个，而页表可能有很多个</li>
</ul>
<h2 id="5_6">5.虚拟存储管理</h2>
<h4 id="1_14">1.传统存储管理</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>分配方式</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>连续分配</td>
<td>1. 单一连续分配<br />2. 固定连续分配<br />3. 动态分区分配</td>
</tr>
<tr>
<td>非连续分配</td>
<td>1. 基本分页存储管理<br />2. 基本分段存储管理<br />3. 基本段页存储管理</td>
</tr>
</tbody>
</table></div>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>缺点</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>一次性</td>
<td>1. 作业很大时，不能全部装入内存，导致大作业无法运行。<br />2. 当大量作业要求运行时，由于内存无法容纳所有作业，因此只有少量作业能运行，导致多道程序并发度下降。</td>
</tr>
<tr>
<td>驻留性</td>
<td>一旦作业被装入内存，就会一直驻留在内存中，直至作业运行结束。</td>
</tr>
</tbody>
</table></div>
<p>事实上，在一个时间段内，只需要访问作业的一小部分数据即可正常运行，这就导致了内存中会驻留大量的、暂时用不到的数据，浪费了宝贵的内存资源。</p>
<h4 id="2_12">2.虚拟内存</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>特征</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>多次性</td>
<td>无需在作业运行时一次性全部装入内存，而是允许被分成多次调入内存。</td>
</tr>
<tr>
<td>对换性</td>
<td>在作业运行时无需一直常驻内存，而是允许在作业运行过程中，将作业换入，换出。</td>
</tr>
<tr>
<td>虚拟性</td>
<td>从逻辑上扩充内存容量。</td>
</tr>
</tbody>
</table></div>
<p>请求分页存储管理</p>
<p><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.10.26-5622238.png" alt="截屏2020-11-17 22.10.26" style="zoom:67%;" /></p>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>实现方式</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>请求分页存储管理</td>
<td>缺页中断（当所要访问的页面不在内存时产生）：<br />1. 在指令执行期间（非指令执行结束后）产生，属于<strong>内部中断</strong>。<br />2. 一条指令在执行期间，可能产生多次缺页中断。<br />3. 缺页进程将被阻塞（调页完成后被唤醒）。</td>
</tr>
<tr>
<td>请求分段存储管理</td>
<td></td>
</tr>
<tr>
<td>请求段页式存储管理</td>
<td></td>
</tr>
</tbody>
</table></div>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>页面置换算法</th>
<th></th>
<th></th>
<th></th>
<th>缺点</th>
</tr>
</thead>
<tbody>
<tr>
<td>最佳置换算法</td>
<td>OPT</td>
<td></td>
<td>淘汰以后永久不用的页面</td>
<td>无法实现</td>
</tr>
<tr>
<td>先进先出页面置换算法</td>
<td>FIFO</td>
<td>队列类算法</td>
<td>淘汰最早进入内存的页面</td>
<td>与进程实际运行规律不适应。<br /><br /><strong>Belady异常</strong>：<br />分配的物理块数增大而缺页次数不减反增的异常现象。</td>
</tr>
<tr>
<td>最近最久未使用置换算法</td>
<td>LRU</td>
<td>堆栈类算法</td>
<td>淘汰最长时间未被访问过的页面</td>
<td>需要寄存器和栈的硬件支持。</td>
</tr>
<tr>
<td>时钟置换算法</td>
<td>CLOCK</td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<td>最近未用算法</td>
<td>NRU</td>
<td></td>
<td>淘汰最近未使用过的页面<br /><br /><strong>访问时</strong>： <br />将访问位置1<br /><br /><strong>淘汰时</strong>： <br />若访问位为0，就将该页换出<br />若访问位为1，就将该页的访问位置0</td>
<td></td>
</tr>
<tr>
<td>改进型的时钟置换算法</td>
<td></td>
<td></td>
<td>对使用过页面做类细分：<br />分为使用过但未修改和使用过已修改</td>
<td></td>
</tr>
</tbody>
</table></div>
<p><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 22.09.56.png" alt="截屏2020-11-17 22.09.56" style="zoom:67%;" /></p>
<p>硬件支持</p>
<ol>
<li>一定容量的内存和外存</li>
<li>页表（段表）机制</li>
<li>中断机构</li>
<li>地址变换机构</li>
</ol>
<h2 id="6_2">6.请求分页存储管理、页面分配策略</h2>
<h4 id="1_15">1. 页面分配</h4>
<ul>
<li>驻留集：请求分页管理中给进程分配的内存块的集合</li>
</ul>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>固定分配局部</th>
<th>可变分配全局置换</th>
<th>可变分配局部置换</th>
</tr>
</thead>
<tbody>
<tr>
<td>策略</td>
<td>为每个进程分配一定数目的物理块，在整个运行期间都不改变。</td>
<td>为系统中的每个进程分配一定数目的物理块，操作系统也保持一个空闲物理块队列。</td>
<td>为每个进程分配一定数目的物理块，当某个进程发生缺页时，只允许该进程在内存中的页面选出一页换出。<br />1. 若进程缺页率较高，系统为该进程分配若干物理块。<br />2. 若进程缺页率较低，系统可以适当减少分配给该进程的物理块。</td>
</tr>
<tr>
<td>优点</td>
<td></td>
<td>1. 最易于实现的物理分配块分配和置换策略。<br />2. 灵活，可以动态增加进程的物理块。</td>
<td>1. 可以动态增加（减少）物理块的数量。<br />2. 保证了系统的多道程序并发能力。</td>
</tr>
<tr>
<td>缺点</td>
<td>1. 难以确定应该为每个进程分配的物理块数。<br />2. 太少，频繁出现缺页中断。<br />3. 太多，使CPU和其他资源利用率下降。</td>
<td>1. 盲目给进程增加物理块，导致系统多道程序的并发能力下降。</td>
<td>1. 需要总复杂的实现机制。<br />2. 需要更大的开销。</td>
</tr>
</tbody>
</table></div>
<h4 id="2_13">2. 调入页面的时机</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>预调页策略</th>
<th>请求调页策略</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td>进程运行前调入。</td>
<td>进程运行期间（缺页时）调入。</td>
</tr>
<tr>
<td>特点</td>
<td>根据局部性原理，一次调入若干相邻的页面可能会比一次调入一页的效率更高。</td>
<td></td>
</tr>
<tr>
<td>缺点</td>
<td></td>
<td>每次只调入一页，调入/调出页面多时，会花费过多的I/O开销。</td>
</tr>
</tbody>
</table></div>
<p>外存</p>
<ul>
<li>对换区：通常采用连续的分配方式，速度快</li>
<li>文件区：通常采用离散的分配方式，速度慢</li>
</ul>
<h4 id="3_11">3. 从何处调入</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>系统有足够的对换区</th>
<th>系统缺少足够的对换区</th>
<th>UNIX方式</th>
</tr>
</thead>
<tbody>
<tr>
<td>运行前</td>
<td>运行前数据从文件区复制到对换区</td>
<td>凡不被修改的文件都直接从文件区调入</td>
<td>第一次使用的页面都从文件区调入</td>
</tr>
<tr>
<td>运行时</td>
<td>在内存和对换区之间进行</td>
<td>会修改的数据调出到对换区<br />需要时再从对换区调入</td>
<td>调出的页面都写回对换区<br />需要时从对换区调入</td>
</tr>
</tbody>
</table></div>
<h4 id="4_10">4. 抖动（颠簸）现象</h4>
<ul>
<li>页面频繁换入换出的现象</li>
<li>原因：分配给进程的物理块不够</li>
</ul>
<h4 id="5_7">5. 工作集</h4>
<ul>
<li>在某段时间间隔内，进程实际访问页面的集合</li>
<li>驻留集大小一般不能小于工作集大小</li>
</ul>
<h3 id="_9">知识点（基本）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点</th>
</tr>
</thead>
<tbody>
<tr>
<td>1. 在【整个系统】中只设置【一个】重定位寄存器，在切换程序时重新装入重定位寄存器。</td>
</tr>
<tr>
<td>2. 采用分段式存储管理时，一个程序如何分段是在【用户编程】时决定的。</td>
</tr>
<tr>
<td>3. 对主存储器的访问【以字或字节】为单位。</td>
</tr>
<tr>
<td>4. 操作系统采用分页管理方式，【每个进程】拥有【一张】页表，且进程的页表【驻留在内存中】。</td>
</tr>
<tr>
<td>5. 一个分段式存储管理系统，地址长度为32位，其中段号占8位，最大段长为【2^24B】。</td>
</tr>
<tr>
<td>6. 在分段式存储管理中，每段是一个连续的存储区，且不一定等长，段与段之间【不一定连续】。</td>
</tr>
<tr>
<td>7. 多级页表：<br />优点：减少页表所占的连续内存空间。<br />缺点：<strong>减慢地址变换速度</strong>，可能增加缺页中断次数增加页表所占字节数。</td>
</tr>
<tr>
<td>8. 在分段式管理系统中，用共享段表描述所有被共享的段。若进程P1和进程P2共享段S<br /><br />A. 在物理内存中仅保存一份段S的内容（✔︎）<br /><strong>B. 段S在P1和P2中具有相同的段号【不正确】</strong> <br />C. P1和P2共享段S在共享段表汇总的段表项（存放物理地址）（✔︎）<br />D. P1和P2都不再使用段S时才回收段S所占的内存空间（✔︎）</td>
</tr>
</tbody>
</table></div>
<h3 id="_10">知识点（内存管理方式，选择题）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（选择题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2009第26题】分区分配内存管理方式的主要保护措施是【A】<br/><br />【A.界地址保护】、B.程序代码保护、C.数据保护、D.栈保护</td>
</tr>
<tr>
<td>【2009第27题】一个分段存储管理系统中，地址长度为 32 位，其中<strong>段号</strong>占 8 位，则最大段长是【C】<br/><br />A. <script type="math/tex">2^8</script> 字节、B. <script type="math/tex">2^{16}</script> 字节、C. <script type="math/tex">2^{24}</script> 字节、D. <script type="math/tex">2^{32}</script> 字节<br /><br />【分析】在该系统中：<script type="math/tex">地址长度[32]=段号[8],段内偏移量[24]</script>
</td>
</tr>
<tr>
<td>【2010第28题】某基于动态分区存储管理的计算机，其主存容量为 55MB(初始为空闲)，采用<strong>最佳适配(Best Fit)</strong>算法，分配和释放的顺序为：分配 15MB，分配 30MB，释放 15MB，分配 8MB，分配 6MB，此时主存中<strong>最大空闲分区</strong>的大小是【B】<br/><br />A.7MB、【B.9MB】、C.10MB、D.15MB<br /><br /><strong>最佳适配(Best Fit)</strong>算法：分配刚好（最佳）的内存空间。</td>
</tr>
<tr>
<td><strong>【2010第29题】某计算机采用二级页表的分页存储管理方式，按字节编址，页大小为 <script type="math/tex">2^{10}</script> 字节，页表项大小为 2 字节，逻辑地址结构为：<script type="math/tex">[页目录号][页号][页内偏移量]</script><br/>逻辑地址空间大小为 <script type="math/tex">2^{16}</script> 页，则表示整个逻辑地址空间的页目录表中包含表项的个数至少是【B】</strong><br /><br />A. 64 【B. 128】 C. 256 D. 512<br /><br />【分析】页大小为 <script type="math/tex">2^{10}</script> 字节，页表项大小为 <script type="math/tex">2</script> 字节，则一页可以存放的页表项数目：<script type="math/tex">2^{10}/2=2^9</script><br />逻辑地址空间大小为 <script type="math/tex">2^{16}</script> 页，即共需要<script type="math/tex">2^{16}</script>个页表项；<br />则表示整个逻辑地址空间的<strong>页目录表中包含表项</strong>的个数至少是：<script type="math/tex">2^{16}/2^9=2^7=128</script>，即需要<script type="math/tex">128</script>页来存放页表项。</td>
</tr>
<tr>
<td>【2011第30题】在虚拟内存管理中，地址变换机构将逻辑地址变换为物理地址，形成该逻辑地址的阶段是【B】<br /><br/>A.编辑 【B.编译】 C.链接 D.装载<br />解答：B。编译过程指编译程序将用户源代码编译成目标模块。源地址编译成目标程序时，会形成逻辑地址。</td>
</tr>
<tr>
<td><strong>【2014第27题】现有一个容量为 10GB 的磁盘分区，磁盘空间以簇(Cluster)为单位进行分配，簇的大小为 4KB，若采用位图法管理该分区的空闲空间，即用一位(bit)标识一个簇是否被分配，则存放该位图所需簇的个数为【A】</strong><br/><br />A.80 B.320 C.80K D.320K<br /><br />&gt; <script type="math/tex">10GB=10*2^{30}B</script><br />&gt; <script type="math/tex">10GB</script>被分成了 <script type="math/tex">\cfrac{10*2^{30}}{4*2^{10}}=2.5*2^{20}</script> 个簇<br />&gt; <script type="math/tex">4KB=4*2^{10}B=32*2^{10}bit</script><br />》<script type="math/tex">\cfrac{2.5*2^{20}}{32*2^{10}}=80</script> 个簇</td>
</tr>
<tr>
<td>【2014第32题】下列选项中，属于多级页表优点的是【D】<br /><br />A.加快地址变换速度（减慢）<br />B.减少缺页中断次数（若都不在一二级页表中，将增加缺页次数）<br />C.减少页表项所占字节数<br />【D.减少页表所占的连续内存空间】</td>
</tr>
<tr>
<td>【2016第28题】某进程的段表内容如下所示。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 20.18.38.png" alt="截屏2020-12-10 20.18.38" style="zoom:67%;" /><br />当访问段号为2、段内地址为400的逻辑地址时，进行地址转换的结果是【D】<br /><br/>A.段缺失异常 <br/>B.得到内存地址4400<br/>C.越权异常<br/>【D.越界异常】<br /><br />本题中，段号为2的段，段长为300，访问段内地址为400的逻辑地址将产生越界异常。</td>
</tr>
<tr>
<td>【2017第25题】某计算机按字节编址，其动态分区内存管理采用<strong>最佳适应算法</strong>，每次分配和回收内存后都对空闲分区链重新排序。当前空闲分区信息如下表所示。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 19.54.01.png" alt="截屏2020-12-10 19.54.01" style="zoom:67%;" /><br />回收起始地址为60 K、大小为140 KB的分区后，系统中空闲分区的数量、空闲分区链第一个分区的起始地址和大小分别是【B】<br/><br />A.3、20 K、380 KB<br />【B.3、500 K、80 KB】<br/>C.4、20 K、180 KB<br />D.4、500 K、80 KB</td>
</tr>
<tr>
<td>【2019第28题】在分段存储管理系统中，用共享段表描述所有共享的段。若进程PI和P2共享段S，下列叙述中，<strong>错误</strong>的是【】<br/><br /><strong>A. 在物理内存中仅保存一份段s的内容</strong><br/>【B. 段S在P1和P2中应该具有相同的段号】（共享段在不同进程中的逻辑段号可能不同）<br/><strong>C. PI和P2共享段S在共享段表中的段表项</strong><br/><strong>D. PI和P2都不再使用段S时才问收段S所占的内存空间</strong></td>
</tr>
<tr>
<td>【2019第31题】某计算机主存按字节编址,采用二级分页存储管理,地址结构如下所示：<br /><script type="math/tex">[页目录号10bit][页号10bit][页内偏移12bit]</script><br />虚拟地址2050 1225H对应的<strong>页目录号</strong>、<strong>页号</strong>分别是【A】<br /><br/>【A. 081H, 101H】<br/>B. 081H, 401H<br/>C. 201H, 101H<br/>D. 201H, 401H<br /><br /><script type="math/tex">2050\ 1225H = [0010\ 0000\ 01][01\ 0000\ 0001]\ [0010\ 0010\ 0101]B</script>
</td>
</tr>
<tr>
<td>【2019第】在下列动态分区分配算法巾,最容易产生内存碎片的是【C】<br/><br />A.首次适应算法<br/>B.最坏适应算法<br/>【C.最佳适应算法】<br/>D.循环首次适应算法</td>
</tr>
</tbody>
</table></div>
<h3 id="_11">知识点（内存管理方式，简答题）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（简答题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2013第46题（8分）】<strong>某计算机主存按字节编址，逻辑地址和物理地址都是 32 位，页表项大小为 4 字 节。请回答下列问题。<br/>(1)若使用一级页表的分页存储管理方式，逻辑地址结构为：</strong><br /><script type="math/tex">[页号(20 位)][页内偏移量(12 位)]</script><br />则页的大小是多少字节?页表最大占用多少字节?<br /><br /><strong>(2)若使用二级页表的分页存储管理方式，逻辑地址结构为：</strong><br /><script type="math/tex">[页目录号(10 位)][页表索引(10 位)][页内偏移量(12 位)]</script><br />设逻辑地址为 LA，请分别给出其对应的页目录号和页表索引的表达式。<br /><br /> (3)采用(1)中的分页存储管理方式，一个代码段起始逻辑地址为 0000 8000H，其长度 为 8 KB，被装载到从物理地址 0090 0000H 开始的连续主存空间中。页表从主存 0020 0000H 开始的物理地址处连续存放，如下图所示(地址大小自下向上递增)。<strong>请计算出该代码段对应的两个页表项的物理地址、这两个页表项中的页框号以及代码页面 2 的起始物理地址。</strong><br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 20.31.57.png" alt="截屏2020-12-10 20.31.57" style="zoom:67%;" /></td>
</tr>
</tbody>
</table></div>
<h3 id="_12">知识点（页面调度算法，选择题）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（选择题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>1. <strong>在所有的页面置换算法中，只有先进先出算法（FIFO）页面置换算法会出现Belady现象。</strong></td>
</tr>
<tr>
<td>2. 当CPU利用率<strong>低</strong>，交换空间的磁盘利用率<strong>极高</strong>，其他设备的利用率<strong>低</strong>时，能够提高系统性能的有：<br />（1）增加内存条来增加物理空间容量。（增大 <u><strong>内存</strong></u> 容量）<br />（2）减少多道程序的度数。<br /><br /><strong>主要原因：主要时由于内存空间不足。</strong></td>
</tr>
<tr>
<td>【2011第28题】在缺页处理过程中，操作系统执行的操作可能【I，II，III】<br /><br /><strong>I.修改页表<br />II.磁盘I/O<br />III.分配页框<br /></strong><br />解答：D。缺页中断调入新页面，肯定要修改页表项和分配页框所以I、III可能发生，同时内存没有页面，需要从外存读入，会发生磁盘I/O。</td>
</tr>
<tr>
<td>【2011第29题】当系统发生抖动(thrashing)时，可用采取的有效措施是【A】<br /><br />【I.撤销部分进程】<br />II.增加磁盘交换区的容量<br />III.提高用户进程的优先级<br/><br />A.仅I、B.仅II、C.仅III、D.仅I、II</td>
</tr>
<tr>
<td>【2012第25题】下列关于虚拟存储器的叙述中，正确的是【D】<br /><br/>A.虚拟存储只能基于连续分配技术<br/>【<strong>B.虚拟存储只能基于非连续分配技术</strong>】<br/>C.虚拟存储容量只受外存容量的限制<br/>D.虚拟存储容量只受内存容量的限制</td>
</tr>
<tr>
<td>【2013第30题】若用户进程访问内存时产生缺页，则下列选项中，操作系统可能执行的操作是【B】<br/><br />I. 处理越界错（错误）<br />【II. 置换页】<br />【III. 分配内存】<br/>A. 仅I、II B. 仅II、III C. 仅I、III D.I、II和III</td>
</tr>
<tr>
<td>【2014第28题】下列措施中，能加快虚实地址转换的是【C】<br/><br />【I.增大快表(TLB)容量】（能够快虚实地址转换的<strong>平均速率</strong>）<br/>【II.让页表常驻内存】<br/>III.增大交换区(swap)<br/><br />A.仅 I<br/>B.仅 II<br/>C.仅 I、II<br/>D.仅 II、III</td>
</tr>
<tr>
<td>【2014第30题】在页式虚拟存储管理系统中，采用某些页面置换算法，会出现 Belady 异常现象，即进程的缺页次数会随着分配给该进程的页框个数的增加而增加。下列算法中，可能出现 <strong>Belady 异常现象</strong>的是【A】<br /><br />I. LRU 算法<br />【II. FIFO 算法】<br />III. OPT 算法<br /><br />A. 仅 II<br />B. 仅 I、II<br />C. 仅 I、III<br />D. 仅 II、III</td>
</tr>
<tr>
<td>【2015第27题】系统为某进程分配了4个页框，该进程已访问的页号序列为2，0，2，9，3，4，2，8，2，4，8，4， 5。若进程要访问的下一页的页号为7，依据LRU算法，应淘汰页的页号是【2】<br /><br />&gt; 4个页框保存了最后4个不同的页序号<br />&gt; <script type="math/tex">2，0，2，9，3，4，2，8，\underline2，4，\underline8，\underline4，\underline5</script><br />&gt; 最长时间未调用的页序号为【2】，应被调出。</td>
</tr>
<tr>
<td>【2015第30题】在请求分页系统中，页面分配策略与页面置换策略不，能组合使用的是【C】<br/><br />A.可变分配，全局置换<br/>B.可变分配，局部置换<br/><u>C.固定分配，全局置换</u>（无此组合）<br/>D.固定分配，局部置换</td>
</tr>
<tr>
<td 4，5，6，0，3，2="4，5，6，0，3，2">【2016第29题】某进程访问页面的序列如下所示。<br /><script type="math/tex">...,1,3,4,5,【6,0,3,2,3,2】,\underline t,0,4,0,3,2,9,2,1,...</script><br />若工作集的窗口大小为6，则在£时刻的工作集为【A】<br/><br />A. {6，0，3，2} <br />B. {2，3，0，4}<br/>C. {0，4，3，2，9} <br />D.</td>
</tr>
<tr>
<td>【2019第29题】某系统采用LRU页置换算法和局部置换策略，若系统为进程P预分配了4个页框,进程P访问页号的序列为0,1,2,7,0,5,3,5,0,2,7,6,则进程访问，上述页的过程中，产生<strong>页置换</strong>的总次数是【5】<br/><br /><script type="math/tex; mode=display">\begin{array}{}  调用  & 0 & 1 & 2 & 7 & 0 & 5 & 3 & 5 & 0 & 2 & 7 & 6 \\  \hline  页框1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ \hline  页框2 &   & 1 & 1 & 1 & 1 & 5 & 5 & 5 & 5 & 5 & 5 & 6 \\ \hline 页框3 &   &   & 2 & 2 & 2 & 2 & 3 & 3 & 3 & 3 & 7 & 7 \\ \hline 页框4 &   &   &   & 7 & 7 & 7 & 7 & 7 & 7 & 2 & 2 & 2 \\ \hline 缺页  & ✔︎ & ✔︎ & ✔︎ & ✔︎ &   & 1✔︎ & 2✔︎ &   &   & 3✔︎ & 4✔︎ & 5✔︎ \\ \end{array}</script>
</td>
</tr>
</tbody>
</table></div>
<h3 id="_13">知识点（页面调度算法，简答题）</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（简答题）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2009第46题（8分）】请求分页管理系统中，假设某进程的页表内容如下表所示：<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 22.39.51.png" alt="截屏2020-12-10 22.39.51" style="zoom:67%;" /><br />页面大小为 4KB，一次内存的访问时间是 100ns，一次快表(TLB)的访问时间是 10ns，处理一次缺页的平均 时间 108ns(已含更新 TLB 和页表的时间)，进程的驻留集大小固定为 2，采用最近最少使用置换算法(LRU)和局 部淘汰策略。假设1TLB 初始为空;2地址转换时先访问 TLB，若 TLB 未命中，再访问页表(忽略访问页表之 后的 TLB 更新时间);3有效位为 0 表示页面不在内存，产生缺页中断，缺页中断处理后，返回到产生缺页中 断的指令处重新执行。设有虚地址访问序列 2362H、1565H、25A5H，请问：<br/>(1) 依次访问上述三个虚地址，各需多少时间?给出计算过程。<br/>(2) 基于上述访问序列，虚地址 1565H 的物理地址是多少?请说明理由。</td>
</tr>
<tr>
<td>【2010第46题（8分）】设某计算机的逻辑地址空间和物理地址空间均为 64KB，按字节编址。若某进程最多需要 6 页(Page) 数据存储空间，页的大小为 1KB，操作系统采用固定分配局部置换策略为此进程分配 4 个页框(Page Frame)。 在时刻 260 前的该进程访问情况如下表所示(访问位即使用位)。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 22.43.38.png" alt="截屏2020-12-10 22.43.38" style="zoom:67%;" /><br />当该进程执行到时刻 260 时，要访问逻辑地址为 17CAH 的数据。请回答下列问题:<br/>(1) 该逻辑地址对应的页号是多少?<br/>(2) 若采用先进先出(FIFO)置换算法，该逻辑地址对应的物理地址是多少?要求给出计算过程。<br/>(3) 若采用时钟(CLOCK)置换算法，该逻辑地址对应的物理地址是多少?要求给出计算过程 (设搜索下一页的指针沿顺时针方向移动，且当前指向 2 号页框，示意图如下) 。<br /><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-12-10 22.44.08.png" alt="截屏2020-12-10 22.44.08" style="zoom:67%;" /></td>
</tr>
<tr>
<td>【2012第45题】某请求分页系统的局部页面置换策略如下：<br/>系统从 0 时刻开始扫描，每隔 5 个时间单位扫描一轮驻留集(扫描时间忽略不计)，本轮没有被访 问过的页框将被系统回收，并放入到空闲页框链尾，其中内容在下一次分配之前不被清空。当发生缺页 时，如果该页曾被使用过且还在空闲页链表中，则重新放回进程的驻留集中；否则，从空闲页框链表头 部取出一个页框。<br/>假设不考虑其它进程的影响和系统开销。初始时进程驻留集为空。目前系统空闲页框链表中页框号 依次为 32、15、21、41。进程 P 依次访问的&lt;虚拟页号，访问时刻&gt;是：&lt;1,1&gt;、&lt;3,2&gt;、&lt;0,4&gt;、&lt;0,6&gt;、 &lt;1,11&gt;、&lt;0,13&gt;、&lt;2,14&gt;。请回答下列问题。<br/>1)访问&lt;0,4&gt;时，对应的页框号是什么? <br />2)访问&lt;1,11&gt;时，对应的页框号是什么?说明理由。 <br />3)访问&lt;2,14&gt;时，对应的页框号是什么?说明理由。 <br />4)该策略是否适合于时间局部性好的程序?说明理由。</td>
</tr>
<tr>
<td>【2015第46题（6分）】某计算机系统按字节编址，采用二级页表的分页存储管理方式，虚拟地址格式如下所示: <br/><br />10位 10位 12位<br/>页目录号 页表索引 页内偏移量<br/><br />请回答下列问题。<br/>(1)页和页框的大小各为多少字节?进程的虚拟地址空间大小为多少页?<br />(2)假定页目录项和页表项均占4个字节，则进程的页目录和页表共占多少页?要求写出计算过程。<br /> (3)若某指令周期内访问的虚拟地址为0100 0000H和0111 2048H，则进行地址转换时共访问多少个二级页表?要求说明坪由。</td>
</tr>
<tr>
<td>【2017第45题（7分）】假定题44给出的计算机M采用二级分页虚拟存储管理方式，虚拟地址格式如下：<br/><br />页目录号(10 位) 页表索引(10 位) 页内偏移量(12 位)<br/><br />请针对题43的函数f1和题44中的机器指令代码，回答下列问题。 <br />(1)函数f1的机器指令代码占多少页?<br/>(2)取第1条指令(push ebp)时，若在进行地址变换的过程中需要访问内存中的页目录和页表，则会分别访问它们各自的第几个表项(编号从0开始)? <br />(3)M的I/O采用中断控制方式。若进程P在调用f1之前通过scanf( )获取n的值，则在执行scanf( )的过程中，进程P的状态会如何变化?CPU是否会进入内核态?</td>
</tr>
<tr>
<td>【2018第45题（8分）】请根据题 44 图给出的虚拟储管理方式，回答下列问题。<br/><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/3A01E725146BE536E8727AF86F1403FA.jpg" alt="3A01E725146BE536E8727AF86F1403FA" style="zoom:67%;" /><br />(1) 某虚拟地址对应的页目录号为 6 ，在相应的页表中对应的页号为 6 ，页内偏移量为 8，该虚拟地址的十六进制表示是什么 ? <br/>(2) 寄存器 PDBR 用于保存当前进程的页目录起始地址，该地址是物理地址还是虚拟地址 ? 进程切换时， PDBR 的内容是否会变化 ? 说明理由。同一进程的线程切换时， PDBR 的内容是否 会变化 ? 说明理由。<br/>(3) 为了支持改进型 CLOCK 置换算法，需要在页表项中设置哪些字段 ?</td>
</tr>
</tbody>
</table></div>
<h1 id="_14">第四章 文件管理</h1>
<h2 id="1_16">1.文件系统基础</h2>
<h3 id="1_17">1. 文件的定义</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>文件的定义</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>数据项</td>
<td>基本数据项：用于描述一个对象的某种属性的一个值<br />组合数据项：由多个基础数据项组成</td>
</tr>
<tr>
<td>记录</td>
<td>一组相关的数据项的集合</td>
</tr>
<tr>
<td>文件</td>
<td>记录式文件： 有结构文件<br />流式文件：无结构文件</td>
</tr>
</tbody>
</table></div>
<h3 id="2_14">2. 文件的属性</h3>
<ol>
<li>名称</li>
<li>标识符：表示文件系统内文件的唯一标签</li>
<li>类型</li>
<li>位置：指向设备和设备上文件的指针</li>
<li>大小</li>
<li>保护</li>
<li>时间</li>
<li>用户标识  </li>
</ol>
<h3 id="3_12">3. 文件的基本操作</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>文件的基本操作</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>创建文件</td>
<td>1. 在文件系统中为文件找到空间<br />2. 在目录中为新文件创建条目</td>
</tr>
<tr>
<td>写文件</td>
<td>执行一个系统调用，指明文件的名称和写入文件的内容</td>
</tr>
<tr>
<td>读文件</td>
<td></td>
</tr>
<tr>
<td>文件重定位（文件寻址）</td>
<td></td>
</tr>
<tr>
<td>删除文件</td>
<td>从文件目录中找到要删除的文件目录项，使之成为空项，然后回收该文件占用的存储空间</td>
</tr>
<tr>
<td>截断文件</td>
<td>允许文件所有属性不变，并删除文件内容</td>
</tr>
</tbody>
</table></div>
<p>在UNIX系统中，一个目录项仅占16B，其中14B是文件名，2B是i结点的指针，在1KB的盘块中可以存放64个目录项。</p>
<h3 id="4_11">4. 文件的逻辑结构</h3>
<ol>
<li>
<p>流式文件：无结构文件</p>
</li>
<li>
<p>记录式文件： 有结构文件</p>
<ol>
<li>顺序文件</li>
<li>索引文件</li>
<li>索引顺序文件</li>
<li>直接文件或散列文件</li>
</ol>
</li>
</ol>
<h2 id="2_15">2. 磁盘索引结点</h2>
<ul>
<li>文件主要标识符</li>
<li>文件类型</li>
<li>文件存取权限</li>
<li>文件物理地址：每个索引结点含有13个地址项</li>
</ul>
<p>他们直接或间接方式给出数据文件所在盘块的编号</p>
<ul>
<li>文件长度</li>
<li>文件链接计数：在本文件系统中所有指向该文件的文件名的指针计数</li>
<li>文件存取时间</li>
<li>索引结点编号</li>
<li>状态</li>
<li>访问计数</li>
<li>逻辑设备编号</li>
<li>链接指针：设置分别指向空闲链表和散列队列的指针</li>
</ul>
<h2 id="3_13">3. 目录结构</h2>
<h3 id="1_18">1. 操作</h3>
<ul>
<li>搜索</li>
<li>创建文件：在目录中添加一个目录项</li>
<li>删除文件</li>
<li>显示目录</li>
<li>修改目录</li>
</ul>
<h3 id="2_16">2. 结构</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>单级目录结构</th>
<th>两级目录结构（多级目录结构）</th>
<th>树形目录结构</th>
<th>无环图目录结构</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.50.31" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.50.31.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.50.44" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.50.44.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.51.10" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.51.10.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.51.23" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.51.23.png" /></td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
<td></td>
<td>文件共享计数器：<br />当计数器为0时，才真正删除文件</td>
</tr>
<tr>
<td>优点</td>
<td></td>
<td>1. 解决多用户之间文件重名的问题</td>
<td>1. 能够有效地对文件分类</td>
<td>1. 利于实现文件共享</td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
<td>2. 能够有效的进行文件管理和保护</td>
<td></td>
</tr>
<tr>
<td>缺点</td>
<td>1. 查找速度慢</td>
<td>1. 缺乏灵活性，不能对文件分类</td>
<td>1. 需要按文件名称逐级访问中间结点<br /><strong>增加了磁盘访问次数</strong>，降低查询速度。</td>
<td>1. 使得系统的管理变得复杂</td>
</tr>
<tr>
<td></td>
<td>2. 文件不允许重名</td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<td></td>
<td>3. 不便于文件共享</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table></div>
<h3 id="4_12">4. 文件拷贝和文件共享</h3>
<p>对（文件共享）文件的修改会被所有用户所见，文件拷贝，不会对原文件进行修改。</p>
<h2 id="4_13">4.文件共享</h2>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>软链接（符号链接）</th>
<th>硬链接</th>
</tr>
</thead>
<tbody>
<tr>
<td>共享方式</td>
<td>利用符号链实现文件共享</td>
<td>基于索引结点的共享方式</td>
</tr>
<tr>
<td>链接文件</td>
<td>引用计数直接复制</td>
<td>引用计数加1</td>
</tr>
<tr>
<td>删除文件</td>
<td>不对软链接操作</td>
<td>引用计数减1<br /><script type="math/tex">引用计数=0</script>：删除文件<br /><script type="math/tex">引用计数>0</script>：保留文件</td>
</tr>
<tr>
<td>优点</td>
<td></td>
<td>查找速度更快</td>
</tr>
</tbody>
</table></div>
<h2 id="5_8">5.文件保护</h2>
<h3 id="1_19">1. 访问控制</h3>
<ol>
<li>
<p>访问控制表：为每个目录增加一个访问控制表（ACL），规定每个用户名及其所允许的访问类型。</p>
</li>
<li>
<p>口令</p>
</li>
<li>密码（加密保护）</li>
</ol>
<h2 id="6_3">6.文件目录实现</h2>
<h3 id="1_20">1. 文件系统类型</h3>
<ul>
<li>FAT32</li>
<li>NTFS</li>
<li>ext2、ext3、ext4</li>
</ul>
<h3 id="2_17">2. 文件系统层级结构</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>层级</th>
<th>功能</th>
</tr>
</thead>
<tbody>
<tr>
<td>用户调用接口</td>
<td>新建、打开....</td>
</tr>
<tr>
<td>文件目录系统</td>
<td>- 管理活跃文件目录表<br/>- 管理读写状态信息表<br/>- 管理用户进程的打开文件表<br/>- 管理与组织存储设备上的文件目录结构<br/>- 调用下一级存取控制模块</td>
</tr>
<tr>
<td>存取控制验证模块</td>
<td></td>
</tr>
<tr>
<td>逻辑文件逻辑系统与文件信息缓冲区</td>
<td>根据文件的逻辑结构将用户要读写的逻辑记录转换成文件逻辑结构内的相应块号</td>
</tr>
<tr>
<td>物理系统文件系</td>
<td>把逻辑记录所在的相应块号转换成实际的物理地址</td>
</tr>
<tr>
<td>辅助分配模块</td>
<td></td>
</tr>
<tr>
<td>设备管理模块</td>
<td>- 分配设备<br/>- 分配设备读写缓冲区<br/>- 磁盘调度<br/>- 启动设备<br/>- 处理设备中断<br/>- 释放设备读写缓冲区<br/>- 释放设备</td>
</tr>
</tbody>
</table></div>
<h3 id="3_14">3. 目录实现</h3>
<ul>
<li>
<ol>
<li>线性列表</li>
</ol>
</li>
<li>
<ol start="2">
<li>哈希表</li>
</ol>
</li>
</ul>
<h2 id="7_1">7.文件实现</h2>
<h3 id="1_21">1. 文件是一种抽象的数据类型</h3>
<ul>
<li>逻辑结构</li>
<li>
<p>物理结构：文件的实现</p>
</li>
<li>
<p>操作方法</p>
</li>
</ul>
<h3 id="2_18">2. 文件分配方式</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>连续分配</th>
<th>链接分配</th>
<th>索引分配</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td></td>
<td>隐式链接：链接添加在盘块的尾部</td>
<td></td>
</tr>
<tr>
<td>图示</td>
<td><img class="pure-img" alt="截屏2020-11-17 21.35.01" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.35.01.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.35.25" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.35.25.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.39.25" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.39.25.png" /></td>
</tr>
<tr>
<td></td>
<td></td>
<td>显式链接：链接文件各物理块的指针被显式提取出来，记录在文件分配表（FAT）中</td>
<td></td>
</tr>
<tr>
<td></td>
<td></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.36.30" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.36.30.png" /></td>
<td></td>
</tr>
<tr>
<td>说明</td>
<td>磁盘地址 + 连续快</td>
<td></td>
<td>链接方案：如果索引表太大，一个索引块装不下，那么可以将多个索引块链接起来存放</td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
<td>多层索引：建立多层索引(原理类似于多级页表)</td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
<td>混合索引：多种索引分配方式的结合<br />例如：一个文件的顶级索引表中，既包含直接地址索引(直接指向数据块)，又包含一级间接索引(指向单层索引表)、还包含两级间接索引(指向两层索引表)。</td>
</tr>
<tr>
<td>优点</td>
<td>连续分配在文件顺序读写时最快</td>
<td>1. 消除了外部碎片，提高了磁盘利用率</td>
<td>1. 支持随机访问</td>
</tr>
<tr>
<td></td>
<td></td>
<td>2. 对文件的增加删除非常方便</td>
<td></td>
</tr>
<tr>
<td></td>
<td></td>
<td>3. 适合可变长度的文件</td>
<td></td>
</tr>
<tr>
<td>缺点</td>
<td>1. 存在外部碎片</td>
<td></td>
<td>1. 索引表需要占用一定的空间</td>
</tr>
<tr>
<td></td>
<td>2. 只适用于长度固定的文件（不方便扩展）</td>
<td></td>
<td></td>
</tr>
</tbody>
</table></div>
<h4 id="_15">超级超级超级重要考点：</h4>
<ol>
<li>
<p>要会根据多层索引、混合索引的结构计算出文件的最大长度<br />
    (Key：各级索引表最大不能超过一个块)</p>
</li>
<li>
<p>要能自己分析访问某个数据块所需要的读磁盘次数<br />
    (Key：FCB中会存有指向顶级索引块的指针，因此可以根据FCB读入顶级索引块。每次读入下一级的索引块都需要一次读磁盘操作。另外，要注意题目条件：顶级索引块是否已调入内存)</p>
</li>
</ol>
<p><img class="pure-img" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.49.59.png" alt="截屏2020-11-17 21.49.59" style="zoom:67%;" /></p>
<h4 id="_16">“文件的某种逻辑结构支持随机存取/随机访问”是指：</h4>
<p>采用这种逻辑结构的文件，可以根据记录号直接算该记录对应的逻辑地址（逻辑块号，块内地址）</p>
<p>RDOS操作系统支持三种分配方式</p>
<h2 id="8">8.文件存储管理</h2>
<h4 id="1_22">1. 存储空间管理</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>空闲表法</th>
<th>空闲链表法</th>
</tr>
</thead>
<tbody>
<tr>
<td><img class="pure-img" alt="截屏2020-11-17 21.25.43" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.25.43.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.26.28" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.26.28.png" /></td>
</tr>
<tr>
<td></td>
<td>将所有空闲盘块（区）拉成一条空闲链</td>
</tr>
<tr>
<td></td>
<td>1. 当用户需要存储空间时，从链首部依次摘下适当数目的空闲盘块（区）给用户</td>
</tr>
<tr>
<td></td>
<td>2. 当用户释放存储空间时，系统回收盘块（区）依次插入到空闲盘块（区）链的末尾</td>
</tr>
<tr>
<td></td>
<td>空闲盘块链</td>
</tr>
<tr>
<td></td>
<td>空闲盘区链：每个盘区包含若干盘块</td>
</tr>
<tr>
<td></td>
<td>优点： 分配和回收一个盘块非常简单</td>
</tr>
</tbody>
</table></div>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>位示图法</th>
<th>成组链表法</th>
</tr>
</thead>
<tbody>
<tr>
<td><img class="pure-img" alt="截屏2020-11-17 21.28.49" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.28.49.png" /></td>
<td><img class="pure-img" alt="截屏2020-11-17 21.29.46" src="https://zromyk.gitee.io/myblog-figurebed/post/计算机考研-操作系统.assets/截屏2020-11-17 21.29.46.png" /></td>
</tr>
<tr>
<td>利用二进制的一位表示磁盘中一个盘块的使用情况</td>
<td>空闲表法和空闲链表法都不适合大型文件系统，会使得空闲表和空闲链表太大</td>
</tr>
</tbody>
</table></div>
<h2 id="9">9.磁盘组织与管理</h2>
<p>磁盘地址：柱面号、盘面号、扇区号（块号）</p>
<h4 id="1_23">1. 磁盘类型</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>磁头</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>固定头磁盘</td>
<td>磁头相对于盘片的径向方向固定，每个磁道一个磁头</td>
</tr>
<tr>
<td>活动头磁盘</td>
<td>磁头可移动，磁头臂可来回伸缩定位磁道</td>
</tr>
</tbody>
</table></div>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>磁盘</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>固定盘磁盘</td>
<td>磁盘永久固定在磁盘驱动器内</td>
</tr>
<tr>
<td>可换盘磁盘</td>
<td>磁盘可替换和移动</td>
</tr>
</tbody>
</table></div>
<h4 id="2_19">2. 磁盘读写操作时间</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>寻找时间</th>
<th>延迟时间</th>
<th>传输时间</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<script type="math/tex">T_s = m * n + s</script>
</td>
<td>
<script type="math/tex">T_r = \cfrac{1}{2r}</script>
</td>
<td>
<script type="math/tex">T_t = \cfrac{b}{rN}</script>
</td>
</tr>
<tr>
<td>
<script type="math/tex">n</script> 条磁道</td>
<td>
<script type="math/tex">r</script> 磁盘每秒转速</td>
<td>b 需要读写的字节数</td>
</tr>
<tr>
<td>
<script type="math/tex">m</script> 与磁盘驱动速度有关的常数，约为0.2ms</td>
<td></td>
<td>
<script type="math/tex">r</script> 磁盘每秒转速</td>
</tr>
<tr>
<td>
<script type="math/tex">s</script> 磁臂启动时间</td>
<td></td>
<td>
<script type="math/tex">N</script> 磁道上的字节数</td>
</tr>
</tbody>
</table></div>
<h4 id="3_15">3. 磁盘调度算法</h4>
<p><strong>磁臂粘着：</strong>有一个或几个进程对某一磁道有着较高的访问频率，即他们反复地请求对一个磁道进行了I/O请求，从而垄断了整个磁盘设备的现象。</p>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>算法</th>
<th></th>
<th>描述</th>
<th>优点</th>
<th>缺点</th>
</tr>
</thead>
<tbody>
<tr>
<td>先来先服务算法</td>
<td>FCFS</td>
<td></td>
<td>无磁臂粘着现象。</td>
<td>平均寻道时间较长。</td>
</tr>
<tr>
<td>最短寻找时间优先算法</td>
<td>SSTF</td>
<td></td>
<td>性能比FCFS好。</td>
<td>不能保证平均寻道时间最短，有“饥饿”现象。</td>
</tr>
<tr>
<td>扫描算法<br />电梯调度算法</td>
<td>SCAN</td>
<td>在磁头<strong>当前移动方向</strong>（有两个扫描方向）上选择与当前磁头所在磁道距离最近的请求为下一次服务对象。</td>
<td>可避免饥饿现象。</td>
<td>对最近扫描过的区域不公平，在访问局部性方面较差。偏向于处理接近最里最外的磁道的访问请求。</td>
</tr>
<tr>
<td>循环扫描算法</td>
<td>C-SCAN</td>
<td>在扫描的基础上规定磁头<strong>单向移动</strong>（只有一个扫描方向）。到达最远端返回时直接快速移动至起始端，而不服务任何请求。</td>
<td>消除了对两端磁道请求的不公平。</td>
<td></td>
</tr>
<tr>
<td>LOOK调度</td>
<td></td>
<td>扫描算法（SCAN）到达<strong>最远端的一个请求</strong>（非磁盘最远端）之后就返回。</td>
<td></td>
<td></td>
</tr>
<tr>
<td>C-LOOK调度</td>
<td></td>
<td>循环扫描算法（C-SCAN）到达<strong>最远端的一个请求</strong>（非磁盘最远端）之后就返回。</td>
<td></td>
<td></td>
</tr>
</tbody>
</table></div>
<h4 id="4_14">4. 磁盘的管理</h4>
<h5 id="1_24">1. 磁盘初始化</h5>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>磁盘初始化</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>低级格式化（物理分区）</td>
<td>在磁盘能够储存数据之前，要对磁盘分成扇区以便磁盘控制器能够进行读和写。</td>
</tr>
<tr>
<td>将磁盘分成由若干个柱面组成的分区</td>
<td></td>
</tr>
<tr>
<td>逻辑格式化（创建文件系统）</td>
<td>操作系统将初始的文件系统数据结构储存到磁盘上。</td>
</tr>
</tbody>
</table></div>
<h5 id="2_20">2. 引导块</h5>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>自举程序</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>说明</td>
<td>计算机启动时运行初始化程序。</td>
</tr>
<tr>
<td>功能</td>
<td>初始化CPU、寄存器、设备控制器和内存。</td>
</tr>
<tr>
<td>其他</td>
<td>1. 自举程序通常保存在ROM中。</td>
</tr>
<tr>
<td></td>
<td>2. 为了避免改变自举代码需要改变ROM硬件问题，只在ROM中保留很小的自举装入程序。</td>
</tr>
<tr>
<td></td>
<td>3. 将完整的自举程序保存在磁盘的驱动块上。</td>
</tr>
</tbody>
</table></div>
<p>启动块位于磁盘的<strong>固定位置</strong>：拥有启动分区的磁盘称为启动磁盘或系统盘。</p>
<h5 id="3_16">3. 坏块</h5>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>坏块</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>产生原因</td>
<td>磁盘有移动部件且容错能力弱。</td>
</tr>
<tr>
<td>处理方式</td>
<td>简单磁盘，如：电子集成驱动器（IDE）<br />1. 逻辑格式化时会扫描磁盘检查坏扇区。</td>
</tr>
<tr>
<td></td>
<td>复杂磁盘，如：小型计算机系统接口（SCSI）<br />1. 控制器维护一个磁盘坏块链表，在磁盘出场时已经初始化，在磁盘的整个使用过程中不断更新。<br />2. 低级格式化时会将一些块作为备用，控制器可以用备用块来逻辑替代坏块。</td>
</tr>
</tbody>
</table></div>
<h3 id="_17">知识点</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点</th>
</tr>
</thead>
<tbody>
<tr>
<td>1.【寻道时间】占用磁盘读写时间最长。</td>
</tr>
<tr>
<td>2. 当一个磁道存储不下时，剩下的部分存在【同一个柱面上的不同盘面】较好。</td>
</tr>
<tr>
<td>3. 在一个操作系统中，在不同的存储介质上，可以采用不同的文件物理结构。</td>
</tr>
<tr>
<td>4. 对一个文件的访问，常由<strong>用户访问权限</strong>和<strong>文件属性</strong>决定。</td>
</tr>
<tr>
<td>5. 文件系统采用树形目录结构之后，对于不同用户的文件，其文件名可以相同。</td>
</tr>
<tr>
<td>6. 为防止文件损坏，应该<strong>备份文件</strong>。</td>
</tr>
</tbody>
</table></div>
<h3 id="_18">知识点</h3>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>知识点（文件相关）</th>
</tr>
</thead>
<tbody>
<tr>
<td>【2009第30题】文件系统中，文件访问控制信息存储的合理位置是【A】<br/><br />【A.文件控制块】<br/>B.文件分配表<br/>C.用户口令表<br/>D.系统注册表</td>
</tr>
<tr>
<td>【2009第31题】设文件 F1 的当前引用计数值为 1，先建立 F1 的符号链接(软链接)文件 F2，再建立 F1 的硬链接文件 F3， 然后删除 F1。此时，F2 和 F3 的引用计数值分别是【B】<br /><br/>A. 0、1 <br/>【B. 1、1】 <br/>C. 1、2 <br/>D. 2、1<br /><br /><strong>软链接</strong>（符号链接）：链接文件，引用计数直接复制，删除文件时，不对软链接进行操作。<br /><strong>硬链接</strong>：链接文件，引用计数直接加1，删除文件时，文件不直接删除，引用计数减1，若值不为0，则不能删除此文件。<br /><br />在本题中：<br />STEP1. 建立 F1 的符号链接(软链接)文件 F2，引用计数不变，为1.<br />STEP2. 建立 F1 的硬链接文件 F3，F3的引用计数+1，为2.<br />STEP3. 删除 F1，F3 的引用计数值-1，为1.</td>
</tr>
<tr>
<td>【2010第31题】设置当前工作目录的主要目的是【C】<br /><br/>A.节省外存空间<br/>B.节省内存空间<br/>【C.加快文件的检索速度】<br/>D.加快文件的读/写速度</td>
</tr>
<tr>
<td>【2012第28题】若一个用户进程通过 read 系统调用读取一个磁盘文件中的数据，则下列关于此过程的叙述中，正确的是【I，II】<br /><br />【I.若该文件的数据不在内存，则该进程进入睡眠等待状态】<br/>【II.请求 read 系统调用会导致 CPU 从用户态切换到核心态】<br/>III.read 系统调用的参数应包含文件的名称（错误，只需要文件描述符）</td>
</tr>
<tr>
<td>【2013第23题】用户在删除某文件的过程中，操作系统<strong>不可能</strong>执行的操作是【A】<br/><br />【A. 删除此文件所在的目录】（并不删除目录）<br/>B. 删除与此文件关联的目录项<br/>C. 删除与此文件对应的文件控制块<br/>D. 释放与此文件关联的内存级冲区</td>
</tr>
<tr>
<td>【2014年考研408第29题】一个文件被用户进程首次打开的过程中，操作系统需要做的是【B】<br /><br />A. 将文件内容读到内存中<br />B. 【将<strong>文件控制块</strong>读到内存中】✔︎（文件控制块FCB）<br />C. 修改文件控制块中的读写权限<br />D. 将文件的数据缓冲区首地址返回给用户进程</td>
</tr>
<tr>
<td>【2017第30题】某文件系统中，针对每个文件，用户类别分为4类:安全管理员、文件主、文件主的伙伴、其他用户；访问权限分为5种:完全控制、执行、修改、读取、写入。若文件控制块中用二 进制位串表示文件权限，为表示不同类别用户对一个文件的访问权限，则􏰀述文件权限的位数 至少应为【20】<br/><br />A.5 B.9 C.12 D.20</td>
</tr>
<tr>
<td>【2017第31题】若文件f1的硬链接为f2，两个进程分别打开f1和f2，获得对应的文件􏰀述符为fd1和fd2， 则下列叙述中，正确的是【B】<br/><br />I.f1和f2的<u>读写指针</u>位置保持相同（错误） <br />【II.f1和f2共享同一个内存索引结点】 <br />【III.fd1和fd2分别指向各自的用户打开文件表中的一项】<br/><br />A.仅III<br />B.仅II、III<br />C.仅I、II<br />D.I、II和III</td>
</tr>
<tr>
<td>【2018第31题】下列优化方法中，可以提高文件访问速度的是【I，II，III，IV】<br /><br /><strong>I.提前读（提前将文件读入缓冲区，可以加快文件访问速度）<br/>II.为文件分配连续的簇<br/>III.延退写（可以减少磁盘访问次数，可以提高文件访问速度）<br/>IV.采用磁盘高速缓存</strong></td>
</tr>
</tbody>
</table></div>
<h1 id="_19">第五章 输入输出管理</h1>
<h2 id="2_21">2. 控制方式</h2>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>程序直接控制方式</th>
<th>中断驱动方式</th>
<th>DMA方式</th>
<th>通道控制方式</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td>计算机从外部设备读取数据到存储器，每次读取一个字的数据。</td>
<td>允许I/O设备主动打断CPU的运行并请求服务。</td>
<td>在I/O设备和内存之间直接开辟数据传输通道。</td>
<td>专门负责输入输出的处理机，把对一个数据块的读写控制干预，减少为对一组数据块的读写控制干预。</td>
</tr>
<tr>
<td>优点</td>
<td></td>
<td></td>
<td>1. 基本传输单位是是数据块。<br />2. 所传输的数据直接送入内存，或相反。<br />3. 仅在传送一个或多个数据块的开始和结束时，才需要CPU干预，整块数据的传输在DMA控制器控制下完成。</td>
<td>1. 有效的提高整个系统的资源利用率。<br/>2. 通道与CPU共享内存。<br/>3. 通道可以同时控制多台设备与内存的数据交互。<br/>4. 可以实现CPU、通道、I/O设备三者的并行操作。</td>
</tr>
<tr>
<td>缺点</td>
<td>CPU资源浪费极大，CPU利用率低。</td>
<td>仍然会消耗CPU资源</td>
<td></td>
<td></td>
</tr>
</tbody>
</table></div>
<h4 id="4_15">4类寄存器</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>寄存器</th>
<th>功能</th>
</tr>
</thead>
<tbody>
<tr>
<td>命令/状态寄存器（CR）</td>
<td>接收从CPU发来的I/O命令，或有关控制信息</td>
</tr>
<tr>
<td>内存地址寄存器（MAR）</td>
<td>输入时：内存的起始目标地址<br />输出时：设备的内存源地址</td>
</tr>
<tr>
<td>数据寄存器（DR）</td>
<td>暂存数据</td>
</tr>
<tr>
<td>数据计数器（DC）</td>
<td></td>
</tr>
</tbody>
</table></div>
<h4 id="3-io">3. I/O系统层次结构</h4>
<ol>
<li>用户层I/O软件</li>
<li>设备独立性软件：实现用户程序与设备驱动器的统一接口、设备命令、设备保护及设备分配与释放</li>
<li>设备驱动程序：与硬件直接相关，负责具体实现系统对设备发出的操作指令</li>
<li>中断处理程序：保存被中断进程的CPU环境，处理中断相关事项</li>
<li>硬件：一个机械部件（设备本身）、一个电子部件（控制器）</li>
</ol>
<h4 id="4_16">4. 设备控制器</h4>
<ol>
<li>设备控制器与CPU的接口：数据线、地址线、控制线</li>
<li>设备控制器与设备的接口</li>
<li>I/O控制逻辑</li>
</ol>
<h2 id="2_22">2. 输入输出设备子系统概述</h2>
<h4 id="1_25">1. 磁盘高速缓存</h4>
<ol>
<li>逻辑上属于磁盘，物理上属于驻留在内存中的盘块</li>
<li>形式：<ol>
<li>在内存中开启一个单独的存储空间作为磁盘高速缓存，大小固定。</li>
<li>把未利用的内存空间作为一个缓冲池，共请求分页系统和磁盘I/O时共享。</li>
</ol>
</li>
</ol>
<h4 id="2_23">2. 缓冲区</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>缓冲区</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>主要目的</td>
<td>1. 缓和CPU和I/O设备间速度的不匹配矛盾。<br/>2. 减少对CPU的中断频率，放宽对CPU中响应时间的限制。<br/>3. 解决基本数据单元大小不匹配的问题。<br/>4. 提高CPU和I/O设备并行性。</td>
</tr>
<tr>
<td>特点</td>
<td>当缓冲区数据<strong>非空</strong>：只能从缓冲区把数据传出<br/>当缓冲区数据<strong>为空</strong>：可以往缓冲区冲入数据，但必须充满缓冲区后，才能把数据传出</td>
</tr>
<tr>
<td>缓冲技术</td>
<td>1. 单缓冲：<br />在设备和处理机之间设置一个缓冲区。<br/>先把被交换的数据写入缓冲区，然后需要数据的设备或处理机从缓冲区取走数据。<br/>时间：<script type="math/tex">max(C, T) + M</script>：<br/><script type="math/tex">C</script> 工作区数据处理时间<br/><script type="math/tex">T</script> 缓冲区数据充满时间<br/><script type="math/tex">M</script> 缓冲区数据全部传出时间<br /><br />2. 双缓冲<br />3. 循环缓冲<br />4. 缓冲池</td>
</tr>
</tbody>
</table></div>
<h2 id="3_17">3. 设备分配与回收</h2>
<h4 id="1_26">1. 设备种类</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>设备种类</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>独占式使用设备</td>
<td></td>
</tr>
<tr>
<td>分时共享使用设备</td>
<td>各进程每次I/O请求操作通过分时交替进行。</td>
</tr>
<tr>
<td>SPOOLing技术<br />假脱机技术</td>
<td>以空间换取时间。</td>
</tr>
<tr>
<td></td>
<td><strong>输入井和输出井</strong>：磁盘上开辟出得两个存储区域。<br />输出井：用于模拟脱机输入时的磁盘，用于收容I/O设备输入的数据。<br />输出井：用于模拟脱机输出时的磁盘，用于收容用户程序的输出数据。</td>
</tr>
<tr>
<td></td>
<td><strong>输入缓冲区和输出缓冲区</strong>：在内存中开辟的两个存储区域。<br />输入缓冲区：暂存输入设备送来的数据，在传送到输入井。<br />输出缓冲区：暂存从输出井送来的数据，再传送到输出设备。</td>
</tr>
</tbody>
</table></div>
<h4 id="2_24">2. 设备分配的数据结构</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th>表</th>
<th>内容</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>设备控制表（DCT）</td>
<td>一个设备控制表表征一个设备。</td>
<td>包含一个控制器控制表（COCT）</td>
</tr>
<tr>
<td>控制器控制表（COCT）</td>
<td></td>
<td>包含一个通道控制表（CHCT）</td>
</tr>
<tr>
<td>通道控制表（CHCT）</td>
<td></td>
<td></td>
</tr>
<tr>
<td>系统设备表（SDT）</td>
<td>记录已经连接到系统中的所有物理设备的情况。</td>
<td>每个系统仅有一张SDT</td>
</tr>
<tr>
<td>逻辑设备表(LUT)</td>
<td>逻辑设备名映射为物理设备名。</td>
<td>整个系统只设置一张LUT<br />为每个用户设置一张LUT</td>
</tr>
</tbody>
</table></div>
<h4 id="3_18">3. 设备分配原则</h4>
<ol>
<li>充分发挥设备的使用效率。</li>
<li>避免造成进程死锁。</li>
<li>将用户程序和具体设备隔离开。</li>
</ol>
<h4 id="4_17">4. 设备分配方式</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>静态分配</th>
<th>动态分配</th>
</tr>
</thead>
<tbody>
<tr>
<td>方式</td>
<td>用于对独占时设备的分配</td>
<td>在进程执行过程中分配</td>
</tr>
<tr>
<td>优点</td>
<td>不会出现死锁</td>
<td>有利于提高设备利用率</td>
</tr>
<tr>
<td>缺点</td>
<td>设备的使用效率低</td>
<td>可能产生进程死锁</td>
</tr>
</tbody>
</table></div>
<h4 id="5_9">5. 安全性</h4>
<div class="pure-table-scrollable"><table class="pure-table pure-table-horizontal">
<thead>
<tr>
<th></th>
<th>安全分配方式</th>
<th>不安全分配方式</th>
</tr>
</thead>
<tbody>
<tr>
<td>方式</td>
<td>每当发出I/O请求后便进入阻塞态</td>
<td>仅当进程所请求的设备被另一设备占用时，才进入阻塞态</td>
</tr>
<tr>
<td>优点</td>
<td>设备分配安全</td>
<td>进程可以同时操作多个设备</td>
</tr>
<tr>
<td>缺点</td>
<td>对同一进程：设备和CPU是串行的</td>
<td>可能产生死锁</td>
</tr>
</tbody>
</table></div>
<h2 id="_20">知识点</h2>
</div>
<div id="nav">
  <div class="navigation">
  <ul class="pure-menu-list">
    <li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.25em;" href="#_1">第一章 操作系统概述</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#1">1.操作系统的特征</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_1">1.特征</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2">2.处理机管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3">3.存储器管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4">4.文件管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5">5.设备管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#2_1">2.操作系统的发展与分类</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#3_1">3.操作系统的运行机制</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_2">1.系统内核程序（内核态）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_2">2.用户自编程序（用户态）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_2">3.特权指令</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_1">4.原语</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_1">5.异常（内中断）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#6">6.中断</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#7">7.系统调用</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_2">知识点</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.25em;" href="#_3">第二章 进程管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#1_3">1.进程与线程</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_4">1.进程的概念和特征</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#1_5">1、进程映像</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_3">2.进程的状态与转换</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#1_6">1、进程状态</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_3">3.进程控制</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#1pcb">1、PCB（进程控制块）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_2">4.进程的组织</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_2">5.进程通信</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#6_1">6.线程的概念与多线程模型</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#2_4">2.处理机调度</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_7">1.调度的概念</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_5">2.调度的时机、切换与过程</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_4">3.进程调度方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_3">4.调度的基本准则</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_3">5.典型的调度算法</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#3_5">3.进程同步</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_8">1.进程同步的基本概念</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_6">2.实现临界区互斥的基本方法</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_6">3.信号量</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#1_9">1.整形信号量（忙碌等待）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#2_7">2.记录型信号量（让权等待）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#3_7">3.利用信号量实现同步</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#4_4">4.利用信号量实现进程互斥</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_5">4.管程</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_4">5.经典同步问题</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#4_6">4.死锁</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_10">1.死锁的概念</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_8">2.死锁的处理策略</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_8">3.死锁预防</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_7">4.死锁避免</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_5">5.死锁的检测和解除</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_4">知识点（进程调度）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_5">知识点（进程调度算法，待续&hellip;）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_6">知识点（进程互斥，选择题）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_7">知识点（进程互斥，简答题）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.25em;" href="#_8">第三章 内存管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#1_11">1.内存管理概念、基本原理和要求</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_12">1.内存管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_9">2.程序装入和链接</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_9">3.地址</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_8">4.内存保护</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#2_10">2.覆盖与交换</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#3_10">3.连续分配管理方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#4_9">4.非连续分配管理方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_13">1.基本分页存储管理方式和基本分段存储管理方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_11">2.段页式管理方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#5_6">5.虚拟存储管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_14">1.传统存储管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_12">2.虚拟内存</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#6_2">6.请求分页存储管理、页面分配策略</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_15">1. 页面分配</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_13">2. 调入页面的时机</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_11">3. 从何处调入</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_10">4. 抖动（颠簸）现象</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_7">5. 工作集</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_9">知识点（基本）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_10">知识点（内存管理方式，选择题）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_11">知识点（内存管理方式，简答题）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_12">知识点（页面调度算法，选择题）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_13">知识点（页面调度算法，简答题）</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.25em;" href="#_14">第四章 文件管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#1_16">1.文件系统基础</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#1_17">1. 文件的定义</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#2_14">2. 文件的属性</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#3_12">3. 文件的基本操作</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#4_11">4. 文件的逻辑结构</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#2_15">2. 磁盘索引结点</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#3_13">3. 目录结构</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#1_18">1. 操作</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#2_16">2. 结构</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#4_12">4. 文件拷贝和文件共享</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#4_13">4.文件共享</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#5_8">5.文件保护</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#1_19">1. 访问控制</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#6_3">6.文件目录实现</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#1_20">1. 文件系统类型</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#2_17">2. 文件系统层级结构</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#3_14">3. 目录实现</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#7_1">7.文件实现</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#1_21">1. 文件是一种抽象的数据类型</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#2_18">2. 文件分配方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#_15">超级超级超级重要考点：</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#_16">“文件的某种逻辑结构支持随机存取/随机访问”是指：</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#8">8.文件存储管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_22">1. 存储空间管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#9">9.磁盘组织与管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_23">1. 磁盘类型</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_19">2. 磁盘读写操作时间</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_15">3. 磁盘调度算法</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_14">4. 磁盘的管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#1_24">1. 磁盘初始化</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#2_20">2. 引导块</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 2.25em;" href="#3_16">3. 坏块</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_17">知识点</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.25em;" href="#_18">知识点</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.25em;" href="#_19">第五章 输入输出管理</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#2_21">2. 控制方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_15">4类寄存器</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3-io">3. I/O系统层次结构</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_16">4. 设备控制器</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#2_22">2. 输入输出设备子系统概述</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_25">1. 磁盘高速缓存</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_23">2. 缓冲区</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#3_17">3. 设备分配与回收</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#1_26">1. 设备种类</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#2_24">2. 设备分配的数据结构</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#3_18">3. 设备分配原则</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#4_17">4. 设备分配方式</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 1.75em;" href="#5_9">5. 安全性</a>
</li>
<li class="pure-menu-item">
  <a class="pure-menu-link" style="padding:0.1em 0em 0.1em 0.75em;" href="#_20">知识点</a>
</li>

  </ul>
</div>

</div>
 
    </div>
  </div>
  <div id="footer">
    <div class="legal pure-g">
  <div class="pure-u-1 u-sm-1-2">
    <p class="legal-license"><a href="https://beian.miit.gov.cn/#/Integrated/index">浙ICP备2020038748号</a></p>
  </div>
  <div class="pure-u-1 u-sm-1-2">
    <p class="legal-links"><a href="https://github.com/zromyk">GitHub</a></p>
    <p class="legal-copyright">Copyright © 2020 Wei Zhou. 保留所有权利。</p>
  </div>
</div>
  </div>
</body>
</html>
